Clover icon

fastjson 1.2.60_preview_04

  1. Project Clover database Tue Apr 9 2024 16:11:52 CDT
  2. Package com.alibaba.fastjson.parser

File JSONLexerBase.java

 
test_bigdecimal: Feature.AllowSingleQuotes is false
test_2: syntax error
test_1: Feature.AllowSingleQuotes is false
test_null: syntax error
test_generic: Feature.AllowSingleQuotes is false
test_1: Feature.AllowSingleQuotes is false
test_map: Feature.AllowSingleQuotes is false
test_bigdecimal: Feature.AllowSingleQuotes is false
test_1: Feature.AllowSingleQuotes is false
test_1: Feature.AllowSingleQuotes is false
test_for_issue: Feature.AllowSingleQuotes is false
test_1: Feature.AllowSingleQuotes is false
test_0: Feature.AllowSingleQuotes is false
test_bigdecimal: Feature.AllowSingleQuotes is false
test_bigdecimal: Feature.AllowSingleQuotes is false
test_error_0: Feature.AllowSingleQuotes is false
test_1: syntax error
test_2: Feature.AllowSingleQuotes is false
test_singleQuote_vo: syntax error
test_url: Feature.AllowSingleQuotes is false
test_2: Feature.AllowSingleQuotes is false
test_url: Feature.AllowSingleQuotes is false
test_date: Feature.AllowSingleQuotes is false
test_special_browsecue: syntax error
test_12: Feature.AllowSingleQuotes is false
test_strings_2: Feature.AllowSingleQuotes is false
test_pattern: Feature.AllowSingleQuotes is false
test_2: Feature.AllowSingleQuotes is false
test_e: Feature.AllowSingleQuotes is false
test_enum_error: Feature.AllowSingleQuotes is false
test_1: Feature.AllowSingleQuotes is false
test_bigdecimal: Feature.AllowSingleQuotes is false
test_strings: Feature.AllowSingleQuotes is false
test_enums: Feature.AllowSingleQuotes is false
test_enum: Feature.AllowSingleQuotes is false
test_string_2: Feature.AllowSingleQuotes is false
test_enum_2: Feature.AllowSingleQuotes is false
test_bytes: Feature.AllowSingleQuotes is false
test_boolean: Feature.AllowSingleQuotes is false
test_bigdecimal: Feature.AllowSingleQuotes is false
test_value: Feature.AllowSingleQuotes is false
test_0: Feature.AllowSingleQuotes is false
test_e: Feature.AllowSingleQuotes is false
test_date_7: Feature.AllowSingleQuotes is false
test_2: Feature.AllowSingleQuotes is false
test_deserializeUsing: syntax error
test_13: Feature.AllowSingleQuotes is false
test_1: Feature.AllowSingleQuotes is false
test_date_5: Feature.AllowSingleQuotes is false
test_2: Feature.AllowSingleQuotes is false
test_0: Feature.AllowSingleQuotes is false
test_strings_: Feature.AllowSingleQuotes is false
test_0: Feature.AllowSingleQuotes is false
test_charArray: syntax error
test_parse: Feature.AllowSingleQuotes is false
test_e: Feature.AllowSingleQuotes is false
 

Coverage histogram

../../../../img/srcFileCovDistChart8.png
31% of files have more coverage

Code metrics

1,430
3,415
95
1
5,319
4,597
1,213
0.36
35.95
95
12.77

Classes

Class Line # Actions
JSONLexerBase 32 3,415 0% 1,213 1,368
0.7230769472.3%
 

Contributing tests

This file is covered by 3206 tests. .

Source view

1    /*
2    * Copyright 1999-2019 Alibaba Group.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    * http://www.apache.org/licenses/LICENSE-2.0
9    *
10    * Unless required by applicable law or agreed to in writing, software
11    * distributed under the License is distributed on an "AS IS" BASIS,
12    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13    * See the License for the specific language governing permissions and
14    * limitations under the License.
15    */
16    package com.alibaba.fastjson.parser;
17   
18    import java.io.Closeable;
19    import java.math.BigDecimal;
20    import java.math.BigInteger;
21    import java.util.*;
22   
23    import com.alibaba.fastjson.JSON;
24    import com.alibaba.fastjson.JSONException;
25    import com.alibaba.fastjson.util.IOUtils;
26   
27    import static com.alibaba.fastjson.parser.JSONToken.*;
28   
29    /**
30    * @author wenshao[szujobs@hotmail.com]
31    */
 
32    public abstract class JSONLexerBase implements JSONLexer, Closeable {
33   
 
34  44 toggle protected void lexError(String key, Object... args) {
35  44 token = ERROR;
36    }
37   
38    protected int token;
39    protected int pos;
40    protected int features;
41   
42    protected char ch;
43    protected int bp;
44   
45    protected int eofPos;
46   
47    /**
48    * A character buffer for literals.
49    */
50    protected char[] sbuf;
51    protected int sp;
52   
53    /**
54    * number start position
55    */
56    protected int np;
57   
58    protected boolean hasSpecial;
59   
60    protected Calendar calendar = null;
61    protected TimeZone timeZone = JSON.defaultTimeZone;
62    protected Locale locale = JSON.defaultLocale;
63   
64    public int matchStat = UNKNOWN;
65   
66    private final static ThreadLocal<char[]> SBUF_LOCAL = new ThreadLocal<char[]>();
67   
68    protected String stringDefaultValue = null;
69   
 
70  20100202 toggle public JSONLexerBase(int features){
71  20100202 this.features = features;
72   
73  20100202 if ((features & Feature.InitStringFieldAsEmpty.mask) != 0) {
74  11 stringDefaultValue = "";
75    }
76   
77  20100202 sbuf = SBUF_LOCAL.get();
78   
79  20100202 if (sbuf == null) {
80  6 sbuf = new char[512];
81    }
82    }
83   
 
84  7 toggle public final int matchStat() {
85  7 return matchStat;
86    }
87   
88    /**
89    * internal method, don't invoke
90    * @param token
91    */
 
92  12004425 toggle public void setToken(int token) {
93  12004425 this.token = token;
94    }
95   
 
96  5243471 toggle public final void nextToken() {
97  5243471 sp = 0;
98   
99  5243471 for (;;) {
100  5245971 pos = bp;
101   
102  5245971 if (ch == '/') {
103  7 skipComment();
104  7 continue;
105    }
106   
107  5245964 if (ch == '"') {
108  40292 scanString();
109  40288 return;
110    }
111   
112  5205672 if (ch == ',') {
113  47739 next();
114  47739 token = COMMA;
115  47739 return;
116    }
117   
118  5157933 if (ch >= '0' && ch <= '9') {
119  53363 scanNumber();
120  53363 return;
121    }
122   
123  5104570 if (ch == '-') {
124  14113 scanNumber();
125  14113 return;
126    }
127   
128  5090457 switch (ch) {
129  98 case '\'':
130  98 if (!isEnabled(Feature.AllowSingleQuotes)) {
131  57 Test failure here throw new JSONException("Feature.AllowSingleQuotes is false");
132    }
133  41 scanStringSingleQuote();
134  36 return;
135  2206 case ' ':
136  10 case '\t':
137  5 case '\b':
138  3 case '\f':
139  263 case '\n':
140  3 case '\r':
141  2490 next();
142  2490 break;
143  595 case 't': // true
144  595 scanTrue();
145  581 return;
146  2511 case 'f': // false
147  2511 scanFalse();
148  2497 return;
149  5692 case 'n': // new,null
150  5692 scanNullOrNew();
151  5685 return;
152  9 case 'T':
153  3 case 'N': // NULL
154  10 case 'S':
155  12 case 'u': // undefined
156  34 scanIdent();
157  34 return;
158  15 case '(':
159  15 next();
160  15 token = LPAREN;
161  15 return;
162  10 case ')':
163  10 next();
164  10 token = RPAREN;
165  10 return;
166  13796 case '[':
167  13796 next();
168  13796 token = LBRACKET;
169  13796 return;
170  6833 case ']':
171  6833 next();
172  6833 token = RBRACKET;
173  6833 return;
174  14077 case '{':
175  14077 next();
176  14077 token = LBRACE;
177  14077 return;
178  22118 case '}':
179  22118 next();
180  22118 token = RBRACE;
181  22118 return;
182  227 case ':':
183  227 next();
184  227 token = COLON;
185  227 return;
186  0 case ';':
187  0 next();
188  0 token = SEMI;
189  0 return;
190  0 case '.':
191  0 next();
192  0 token = DOT;
193  0 return;
194  5 case '+':
195  5 next();
196  5 scanNumber();
197  5 return;
198  4 case 'x':
199  4 scanHex();
200  4 return;
201  5021950 default:
202  5021950 if (isEOF()) { // JLS
203  5021903 if (token == EOF) {
204  1 throw new JSONException("EOF error");
205    }
206   
207  5021902 token = EOF;
208  5021902 eofPos = pos = bp;
209    } else {
210  47 if (ch <= 31 || ch == 127) {
211  3 next();
212  3 break;
213    }
214   
215  44 lexError("illegal.char", String.valueOf((int) ch));
216  44 next();
217    }
218   
219  5021946 return;
220    }
221    }
222   
223    }
224   
 
225  40360399 toggle public final void nextToken(int expect) {
226  40360399 sp = 0;
227   
228  40360399 for (;;) {
229  40363714 switch (expect) {
230  67777 case JSONToken.LBRACE:
231  67777 if (ch == '{') {
232  63029 token = JSONToken.LBRACE;
233  63029 next();
234  63029 return;
235    }
236  4748 if (ch == '[') {
237  4112 token = JSONToken.LBRACKET;
238  4112 next();
239  4112 return;
240    }
241  636 break;
242  20161866 case JSONToken.COMMA:
243  20161866 if (ch == ',') {
244  130284 token = JSONToken.COMMA;
245  130284 next();
246  130284 return;
247    }
248   
249  20031582 if (ch == '}') {
250  13833 token = JSONToken.RBRACE;
251  13833 next();
252  13833 return;
253    }
254   
255  20017749 if (ch == ']') {
256  20008679 token = JSONToken.RBRACKET;
257  20008679 next();
258  20008679 return;
259    }
260   
261  9070 if (ch == EOI) {
262  7612 token = JSONToken.EOF;
263  7612 return;
264    }
265   
266  1458 if (ch == 'n') {
267  16 scanNullOrNew(false);
268  0 return;
269    }
270  1442 break;
271  10003294 case JSONToken.LITERAL_INT:
272  10003294 if (ch >= '0' && ch <= '9') {
273  10000699 pos = bp;
274  10000699 scanNumber();
275  10000699 return;
276    }
277   
278  2595 if (ch == '"') {
279  2117 pos = bp;
280  2117 scanString();
281  2117 return;
282    }
283   
284  478 if (ch == '[') {
285  39 token = JSONToken.LBRACKET;
286  39 next();
287  39 return;
288    }
289   
290  439 if (ch == '{') {
291  31 token = JSONToken.LBRACE;
292  31 next();
293  31 return;
294    }
295   
296  408 break;
297  126936 case JSONToken.LITERAL_STRING:
298  126936 if (ch == '"') {
299  87555 pos = bp;
300  87555 scanString();
301  87553 return;
302    }
303   
304  39381 if (ch >= '0' && ch <= '9') {
305  23645 pos = bp;
306  23645 scanNumber();
307  23645 return;
308    }
309   
310  15736 if (ch == '[') {
311  897 token = JSONToken.LBRACKET;
312  897 next();
313  897 return;
314    }
315   
316  14839 if (ch == '{') {
317  10375 token = JSONToken.LBRACE;
318  10375 next();
319  10375 return;
320    }
321  4464 break;
322  10000097 case JSONToken.LBRACKET:
323  10000097 if (ch == '[') {
324  10000062 token = JSONToken.LBRACKET;
325  10000062 next();
326  10000062 return;
327    }
328   
329  35 if (ch == '{') {
330  7 token = JSONToken.LBRACE;
331  7 next();
332  7 return;
333    }
334  28 break;
335  4 case JSONToken.RBRACKET:
336  4 if (ch == ']') {
337  1 token = JSONToken.RBRACKET;
338  1 next();
339  1 return;
340    }
341  2 case JSONToken.EOF:
342  5 if (ch == EOI) {
343  1 token = JSONToken.EOF;
344  1 return;
345    }
346  4 break;
347  155 case JSONToken.IDENTIFIER:
348  155 nextIdent();
349  155 return;
350  3583 default:
351  3583 break;
352    }
353   
354  10565 if (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t' || ch == '\f' || ch == '\b') {
355  3315 next();
356  3315 continue;
357    }
358   
359  7250 Test failure here nextToken();
360  7217 break;
361    }
362    }
363   
 
364  158 toggle public final void nextIdent() {
365  184 while (isWhitespace(ch)) {
366  26 next();
367    }
368  158 if (ch == '_' || ch == '$' || Character.isLetter(ch)) {
369  33 scanIdent();
370    } else {
371  125 nextToken();
372    }
373    }
374   
 
375  7899 toggle public final void nextTokenWithColon() {
376  7899 nextTokenWithChar(':');
377    }
378   
 
379  71683 toggle public final void nextTokenWithChar(char expect) {
380  71683 sp = 0;
381   
382  71683 for (;;) {
383  71734 if (ch == expect) {
384  71678 next();
385  71678 Test failure here nextToken();
386  71650 return;
387    }
388   
389  56 if (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t' || ch == '\f' || ch == '\b') {
390  51 next();
391  51 continue;
392    }
393   
394  5 throw new JSONException("not match " + expect + " - " + ch + ", info : " + this.info());
395    }
396    }
397   
 
398  190513379 toggle public final int token() {
399  190513379 return token;
400    }
401   
 
402  21 toggle public final String tokenName() {
403  21 return JSONToken.name(token);
404    }
405   
 
406  30 toggle public final int pos() {
407  30 return pos;
408    }
409   
 
410  517 toggle public final String stringDefaultValue() {
411  517 return stringDefaultValue;
412    }
413   
 
414  1070432 toggle public final Number integerValue() throws NumberFormatException {
415  1070432 long result = 0;
416  1070432 boolean negative = false;
417  1070432 if (np == -1) {
418  6 np = 0;
419    }
420  1070432 int i = np, max = np + sp;
421  1070432 long limit;
422  1070432 long multmin;
423  1070432 int digit;
424   
425  1070432 char type = ' ';
426   
427  1070432 switch (charAt(max - 1)) {
428  24 case 'L':
429  24 max--;
430  24 type = 'L';
431  24 break;
432  6 case 'S':
433  6 max--;
434  6 type = 'S';
435  6 break;
436  13 case 'B':
437  13 max--;
438  13 type = 'B';
439  13 break;
440  1070389 default:
441  1070389 break;
442    }
443   
444  1070432 if (charAt(np) == '-') {
445  10245 negative = true;
446  10245 limit = Long.MIN_VALUE;
447  10245 i++;
448    } else {
449  1060187 limit = -Long.MAX_VALUE;
450    }
451  1070432 multmin = MULTMIN_RADIX_TEN;
452  1070432 if (i < max) {
453  1070428 digit = charAt(i++) - '0';
454  1070428 result = -digit;
455    }
456  1580731 while (i < max) {
457    // Accumulating negatively avoids surprises near MAX_VALUE
458  510305 digit = charAt(i++) - '0';
459  510305 if (result < multmin) {
460  4 return new BigInteger(numberString());
461    }
462  510301 result *= 10;
463  510301 if (result < limit + digit) {
464  2 return new BigInteger(numberString());
465    }
466  510299 result -= digit;
467    }
468   
469  1070426 if (negative) {
470  10243 if (i > np + 1) {
471  10240 if (result >= Integer.MIN_VALUE && type != 'L') {
472  233 if (type == 'S') {
473  3 return (short) result;
474    }
475   
476  230 if (type == 'B') {
477  2 return (byte) result;
478    }
479   
480  228 return (int) result;
481    }
482  10007 return result;
483    } else { /* Only got "-" */
484  3 throw new NumberFormatException(numberString());
485    }
486    } else {
487  1060183 result = -result;
488  1060183 if (result <= Integer.MAX_VALUE && type != 'L') {
489  1045595 if (type == 'S') {
490  3 return (short) result;
491    }
492   
493  1045592 if (type == 'B') {
494  11 return (byte) result;
495    }
496   
497  1045581 return (int) result;
498    }
499  14588 return result;
500    }
501    }
502   
 
503  63784 toggle public final void nextTokenWithColon(int expect) {
504  63784 Test failure here nextTokenWithChar(':');
505    }
506   
 
507  10000165 toggle public float floatValue() {
508  10000165 String strVal = numberString();
509  10000165 float floatValue = Float.parseFloat(strVal);
510  10000165 if (floatValue == 0 || floatValue == Float.POSITIVE_INFINITY) {
511  4 char c0 = strVal.charAt(0);
512  4 if (c0 > '0' && c0 <= '9') {
513  2 throw new JSONException("float overflow : " + strVal);
514    }
515    }
516  10000163 return floatValue;
517    }
518   
 
519  1636 toggle public double doubleValue() {
520  1636 return Double.parseDouble(numberString());
521    }
522   
 
523  161 toggle public void config(Feature feature, boolean state) {
524  161 features = Feature.config(features, feature, state);
525   
526  160 if ((features & Feature.InitStringFieldAsEmpty.mask) != 0) {
527  0 stringDefaultValue = "";
528    }
529    }
530   
 
531  115879663 toggle public final boolean isEnabled(Feature feature) {
532  115879663 return isEnabled(feature.mask);
533    }
534   
 
535  122006751 toggle public final boolean isEnabled(int feature) {
536  122006751 return (this.features & feature) != 0;
537    }
538   
 
539  12000162 toggle public final boolean isEnabled(int features, int feature) {
540  12000162 return (this.features & feature) != 0 || (features & feature) != 0;
541    }
542   
543    public abstract String numberString();
544   
545    public abstract boolean isEOF();
546   
 
547  52418868 toggle public final char getCurrent() {
548  52418868 return ch;
549    }
550   
551    public abstract char charAt(int index);
552   
553    // public final char next() {
554    // ch = doNext();
555    //// if (ch == '/' && (this.features & Feature.AllowComment.mask) != 0) {
556    //// skipComment();
557    //// }
558    // return ch;
559    // }
560   
561    public abstract char next();
562   
 
563  33 toggle protected void skipComment() {
564  33 next();
565  33 if (ch == '/') {
566  12 for (;;) {
567  166 next();
568  166 if (ch == '\n') {
569  9 next();
570  9 return;
571  157 } else if (ch == EOI) {
572  3 return;
573    }
574    }
575  21 } else if (ch == '*') {
576  20 next();
577   
578  143 for (; ch != EOI;) {
579  143 if (ch == '*') {
580  48 next();
581  48 if (ch == '/') {
582  20 next();
583  20 return;
584    } else {
585  28 continue;
586    }
587    }
588  95 next();
589    }
590    } else {
591  1 throw new JSONException("invalid comment");
592    }
593    }
594   
 
595  30718 toggle public final String scanSymbol(final SymbolTable symbolTable) {
596  30718 skipWhitespace();
597   
598  30718 if (ch == '"') {
599  28562 return scanSymbol(symbolTable, '"');
600    }
601   
602  2156 if (ch == '\'') {
603  18 if (!isEnabled(Feature.AllowSingleQuotes)) {
604  11 Test failure here throw new JSONException("syntax error");
605    }
606   
607  7 return scanSymbol(symbolTable, '\'');
608    }
609   
610  2138 if (ch == '}') {
611  368 next();
612  368 token = JSONToken.RBRACE;
613  368 return null;
614    }
615   
616  1770 if (ch == ',') {
617  1603 next();
618  1603 token = JSONToken.COMMA;
619  1603 return null;
620    }
621   
622  167 if (ch == EOI) {
623  31 token = JSONToken.EOF;
624  31 return null;
625    }
626   
627  136 if (!isEnabled(Feature.AllowUnQuotedFieldNames)) {
628  2 throw new JSONException("syntax error");
629    }
630   
631  134 return scanSymbolUnQuoted(symbolTable);
632    }
633   
634    // public abstract String scanSymbol(final SymbolTable symbolTable, final char quote);
635   
636    protected abstract void arrayCopy(int srcPos, char[] dest, int destPos, int length);
637   
 
638  5140336 toggle public final String scanSymbol(final SymbolTable symbolTable, final char quote) {
639  5140336 int hash = 0;
640   
641  5140336 np = bp;
642  5140336 sp = 0;
643  5140336 boolean hasSpecial = false;
644  5140336 char chLocal;
645  5140336 for (;;) {
646  24277095 chLocal = next();
647   
648  24277095 if (chLocal == quote) {
649  5140332 break;
650    }
651   
652  19136763 if (chLocal == EOI) {
653  3 throw new JSONException("unclosed.str");
654    }
655   
656  19136760 if (chLocal == '\\') {
657  133 if (!hasSpecial) {
658  34 hasSpecial = true;
659   
660  34 if (sp >= sbuf.length) {
661  1 int newCapcity = sbuf.length * 2;
662  1 if (sp > newCapcity) {
663  0 newCapcity = sp;
664    }
665  1 char[] newsbuf = new char[newCapcity];
666  1 System.arraycopy(sbuf, 0, newsbuf, 0, sbuf.length);
667  1 sbuf = newsbuf;
668    }
669   
670    // text.getChars(np + 1, np + 1 + sp, sbuf, 0);
671    // System.arraycopy(this.buf, np + 1, sbuf, 0, sp);
672  34 arrayCopy(np + 1, sbuf, 0, sp);
673    }
674   
675  133 chLocal = next();
676   
677  133 switch (chLocal) {
678  1 case '0':
679  1 hash = 31 * hash + (int) chLocal;
680  1 putChar('\0');
681  1 break;
682  1 case '1':
683  1 hash = 31 * hash + (int) chLocal;
684  1 putChar('\1');
685  1 break;
686  1 case '2':
687  1 hash = 31 * hash + (int) chLocal;
688  1 putChar('\2');
689  1 break;
690  1 case '3':
691  1 hash = 31 * hash + (int) chLocal;
692  1 putChar('\3');
693  1 break;
694  1 case '4':
695  1 hash = 31 * hash + (int) chLocal;
696  1 putChar('\4');
697  1 break;
698  1 case '5':
699  1 hash = 31 * hash + (int) chLocal;
700  1 putChar('\5');
701  1 break;
702  1 case '6':
703  1 hash = 31 * hash + (int) chLocal;
704  1 putChar('\6');
705  1 break;
706  1 case '7':
707  1 hash = 31 * hash + (int) chLocal;
708  1 putChar('\7');
709  1 break;
710  2 case 'b': // 8
711  2 hash = 31 * hash + (int) '\b';
712  2 putChar('\b');
713  2 break;
714  6 case 't': // 9
715  6 hash = 31 * hash + (int) '\t';
716  6 putChar('\t');
717  6 break;
718  2 case 'n': // 10
719  2 hash = 31 * hash + (int) '\n';
720  2 putChar('\n');
721  2 break;
722  1 case 'v': // 11
723  1 hash = 31 * hash + (int) '\u000B';
724  1 putChar('\u000B');
725  1 break;
726  1 case 'f': // 12
727  1 case 'F':
728  2 hash = 31 * hash + (int) '\f';
729  2 putChar('\f');
730  2 break;
731  1 case 'r': // 13
732  1 hash = 31 * hash + (int) '\r';
733  1 putChar('\r');
734  1 break;
735  50 case '"': // 34
736  50 hash = 31 * hash + (int) '"';
737  50 putChar('"');
738  50 break;
739  1 case '\'': // 39
740  1 hash = 31 * hash + (int) '\'';
741  1 putChar('\'');
742  1 break;
743  1 case '/': // 47
744  1 hash = 31 * hash + (int) '/';
745  1 putChar('/');
746  1 break;
747  50 case '\\': // 92
748  50 hash = 31 * hash + (int) '\\';
749  50 putChar('\\');
750  50 break;
751  1 case 'x':
752  1 char x1 = ch = next();
753  1 char x2 = ch = next();
754   
755  1 int x_val = digits[x1] * 16 + digits[x2];
756  1 char x_char = (char) x_val;
757  1 hash = 31 * hash + (int) x_char;
758  1 putChar(x_char);
759  1 break;
760  7 case 'u':
761  7 char c1 = chLocal = next();
762  7 char c2 = chLocal = next();
763  7 char c3 = chLocal = next();
764  7 char c4 = chLocal = next();
765  7 int val = Integer.parseInt(new String(new char[] { c1, c2, c3, c4 }), 16);
766  7 hash = 31 * hash + val;
767  7 putChar((char) val);
768  7 break;
769  1 default:
770  1 this.ch = chLocal;
771  1 throw new JSONException("unclosed.str.lit");
772    }
773  132 continue;
774    }
775   
776  19136627 hash = 31 * hash + chLocal;
777   
778  19136627 if (!hasSpecial) {
779  19084798 sp++;
780  19084798 continue;
781    }
782   
783  51829 if (sp == sbuf.length) {
784  12 putChar(chLocal);
785    } else {
786  51817 sbuf[sp++] = chLocal;
787    }
788    }
789   
790  5140332 token = LITERAL_STRING;
791   
792  5140332 String value;
793  5140332 if (!hasSpecial) {
794    // return this.text.substring(np + 1, np + 1 + sp).intern();
795  5140299 int offset;
796  5140299 if (np == -1) {
797  0 offset = 0;
798    } else {
799  5140299 offset = np + 1;
800    }
801  5140299 value = addSymbol(offset, sp, hash, symbolTable);
802    } else {
803  33 value = symbolTable.addSymbol(sbuf, 0, sp, hash);
804    }
805   
806  5140332 sp = 0;
807  5140332 this.next();
808   
809  5140332 return value;
810    }
811   
 
812  10106703 toggle public final void resetStringPosition() {
813  10106703 this.sp = 0;
814    }
815   
 
816  18 toggle public String info() {
817  18 return "";
818    }
819   
 
820  224 toggle public final String scanSymbolUnQuoted(final SymbolTable symbolTable) {
821  220 if (token == JSONToken.ERROR && pos == 0 && bp == 1) {
822  0 bp = 0; // adjust
823    }
824  224 final boolean[] firstIdentifierFlags = IOUtils.firstIdentifierFlags;
825  224 final char first = ch;
826   
827  224 final boolean firstFlag = ch >= firstIdentifierFlags.length || firstIdentifierFlags[first];
828  224 if (!firstFlag) {
829  16 throw new JSONException("illegal identifier : " + ch //
830    + info());
831    }
832   
833  208 final boolean[] identifierFlags = IOUtils.identifierFlags;
834   
835  208 int hash = first;
836   
837  208 np = bp;
838  208 sp = 1;
839  208 char chLocal;
840  208 for (;;) {
841  888 chLocal = next();
842   
843  888 if (chLocal < identifierFlags.length) {
844  888 if (!identifierFlags[chLocal]) {
845  208 break;
846    }
847    }
848   
849  680 hash = 31 * hash + chLocal;
850   
851  680 sp++;
852  680 continue;
853    }
854   
855  208 this.ch = charAt(bp);
856  208 token = JSONToken.IDENTIFIER;
857   
858  208 final int NULL_HASH = 3392903;
859  208 if (sp == 4 && hash == NULL_HASH && charAt(np) == 'n' && charAt(np + 1) == 'u' && charAt(np + 2) == 'l'
860    && charAt(np + 3) == 'l') {
861  3 return null;
862    }
863   
864    // return text.substring(np, np + sp).intern();
865   
866  205 if (symbolTable == null) {
867  0 return subString(np, sp);
868    }
869   
870  205 return this.addSymbol(np, sp, hash, symbolTable);
871    // return symbolTable.addSymbol(buf, np, sp, hash);
872    }
873   
874    protected abstract void copyTo(int offset, int count, char[] dest);
875   
 
876  157939 toggle public final void scanString() {
877  157939 np = bp;
878  157939 hasSpecial = false;
879  157939 char ch;
880  157939 for (;;) {
881  6828550 ch = next();
882   
883  6828548 if (ch == '\"') {
884  157929 break;
885    }
886   
887  6670619 if (ch == EOI) {
888  7 if (!isEOF()) {
889  1 putChar((char) EOI);
890  1 continue;
891    }
892  6 throw new JSONException("unclosed string : " + ch);
893    }
894   
895  6670612 if (ch == '\\') {
896  1208815 if (!hasSpecial) {
897  33416 hasSpecial = true;
898   
899  33416 if (sp >= sbuf.length) {
900  3 int newCapcity = sbuf.length * 2;
901  3 if (sp > newCapcity) {
902  3 newCapcity = sp;
903    }
904  3 char[] newsbuf = new char[newCapcity];
905  3 System.arraycopy(sbuf, 0, newsbuf, 0, sbuf.length);
906  3 sbuf = newsbuf;
907    }
908   
909  33416 copyTo(np + 1, sp, sbuf);
910    // text.getChars(np + 1, np + 1 + sp, sbuf, 0);
911    // System.arraycopy(buf, np + 1, sbuf, 0, sp);
912    }
913   
914  1208815 ch = next();
915   
916  1208815 switch (ch) {
917  1 case '0':
918  1 putChar('\0');
919  1 break;
920  1 case '1':
921  1 putChar('\1');
922  1 break;
923  1 case '2':
924  1 putChar('\2');
925  1 break;
926  1 case '3':
927  1 putChar('\3');
928  1 break;
929  1 case '4':
930  1 putChar('\4');
931  1 break;
932  1 case '5':
933  1 putChar('\5');
934  1 break;
935  1 case '6':
936  1 putChar('\6');
937  1 break;
938  1 case '7':
939  1 putChar('\7');
940  1 break;
941  12110 case 'b': // 8
942  12110 putChar('\b');
943  12110 break;
944  12288 case 't': // 9
945  12288 putChar('\t');
946  12288 break;
947  29186 case 'n': // 10
948  29186 putChar('\n');
949  29186 break;
950  1 case 'v': // 11
951  1 putChar('\u000B');
952  1 break;
953  12169 case 'f': // 12
954  0 case 'F':
955  12169 putChar('\f');
956  12169 break;
957  13056 case 'r': // 13
958  13056 putChar('\r');
959  13056 break;
960  15864 case '"': // 34
961  15864 putChar('"');
962  15864 break;
963  3 case '\'': // 39
964  3 putChar('\'');
965  3 break;
966  4254 case '/': // 47
967  4254 putChar('/');
968  4254 break;
969  12149 case '\\': // 92
970  12149 putChar('\\');
971  12149 break;
972  257 case 'x':
973  257 char x1 = next();
974  257 char x2 = next();
975   
976  257 boolean hex1 = (x1 >= '0' && x1 <= '9')
977    || (x1 >= 'a' && x1 <= 'f')
978    || (x1 >= 'A' && x1 <= 'F');
979  257 boolean hex2 = (x2 >= '0' && x2 <= '9')
980    || (x2 >= 'a' && x2 <= 'f')
981    || (x2 >= 'A' && x2 <= 'F');
982  257 if (!hex1 || !hex2) {
983  1 throw new JSONException("invalid escape character \\x" + x1 + x2);
984    }
985   
986  256 char x_char = (char) (digits[x1] * 16 + digits[x2]);
987  256 putChar(x_char);
988  256 break;
989  1097469 case 'u':
990  1097469 char u1 = next();
991  1097469 char u2 = next();
992  1097469 char u3 = next();
993  1097469 char u4 = next();
994  1097469 int val = Integer.parseInt(new String(new char[] { u1, u2, u3, u4 }), 16);
995  1097469 putChar((char) val);
996  1097469 break;
997  1 default:
998  1 this.ch = ch;
999  1 throw new JSONException("unclosed string : " + ch);
1000    }
1001  1208813 continue;
1002    }
1003   
1004  5461797 if (!hasSpecial) {
1005  2572641 sp++;
1006  2572641 continue;
1007    }
1008   
1009  2889156 if (sp == sbuf.length) {
1010  19 putChar(ch);
1011    } else {
1012  2889137 sbuf[sp++] = ch;
1013    }
1014    }
1015   
1016  157929 token = JSONToken.LITERAL_STRING;
1017  157929 this.ch = next();
1018    }
1019   
 
1020  122 toggle public Calendar getCalendar() {
1021  122 return this.calendar;
1022    }
1023   
 
1024  52 toggle public TimeZone getTimeZone() {
1025  52 return timeZone;
1026    }
1027   
 
1028  4 toggle public void setTimeZone(TimeZone timeZone) {
1029  4 this.timeZone = timeZone;
1030    }
1031   
 
1032  52 toggle public Locale getLocale() {
1033  52 return locale;
1034    }
1035   
 
1036  1 toggle public void setLocale(Locale locale) {
1037  1 this.locale = locale;
1038    }
1039   
 
1040  36881 toggle public final int intValue() {
1041  36881 if (np == -1) {
1042  0 np = 0;
1043    }
1044   
1045  36881 int result = 0;
1046  36881 boolean negative = false;
1047  36881 int i = np, max = np + sp;
1048  36881 int limit;
1049  36881 int digit;
1050   
1051  36881 if (charAt(np) == '-') {
1052  105 negative = true;
1053  105 limit = Integer.MIN_VALUE;
1054  105 i++;
1055    } else {
1056  36776 limit = -Integer.MAX_VALUE;
1057    }
1058  36881 long multmin = INT_MULTMIN_RADIX_TEN;
1059  36881 if (i < max) {
1060  36880 digit = charAt(i++) - '0';
1061  36880 result = -digit;
1062    }
1063  47772 while (i < max) {
1064    // Accumulating negatively avoids surprises near MAX_VALUE
1065  10910 char chLocal = charAt(i++);
1066   
1067  10910 if (chLocal == 'L' || chLocal == 'S' || chLocal == 'B') {
1068  4 break;
1069    }
1070   
1071  10906 digit = chLocal - '0';
1072   
1073  10906 if (result < multmin) {
1074  8 throw new NumberFormatException(numberString());
1075    }
1076  10898 result *= 10;
1077  10898 if (result < limit + digit) {
1078  7 throw new NumberFormatException(numberString());
1079    }
1080  10891 result -= digit;
1081    }
1082   
1083  36866 if (negative) {
1084  102 if (i > np + 1) {
1085  101 return result;
1086    } else { /* Only got "-" */
1087  1 throw new NumberFormatException(numberString());
1088    }
1089    } else {
1090  36764 return -result;
1091    }
1092    }
1093   
1094    public abstract byte[] bytesValue();
1095   
 
1096  20099124 toggle public void close() {
1097  20099124 if (sbuf.length <= 1024 * 8) {
1098  20099117 SBUF_LOCAL.set(sbuf);
1099    }
1100  20099124 this.sbuf = null;
1101    }
1102   
 
1103  30 toggle public final boolean isRef() {
1104  30 if (sp != 4) {
1105  16 return false;
1106    }
1107   
1108  14 return charAt(np + 1) == '$' //
1109    && charAt(np + 2) == 'r' //
1110    && charAt(np + 3) == 'e' //
1111    && charAt(np + 4) == 'f';
1112    }
1113   
1114    protected final static char[] typeFieldName = ("\"" + JSON.DEFAULT_TYPE_KEY + "\":\"").toCharArray();
1115   
 
1116  3054741 toggle public final int scanType(String type) {
1117  3054741 matchStat = UNKNOWN;
1118   
1119  3054741 if (!charArrayCompare(typeFieldName)) {
1120  3054739 return NOT_MATCH_NAME;
1121    }
1122   
1123  2 int bpLocal = this.bp + typeFieldName.length;
1124   
1125  2 final int typeLength = type.length();
1126  58 for (int i = 0; i < typeLength; ++i) {
1127  58 if (type.charAt(i) != charAt(bpLocal + i)) {
1128  2 return NOT_MATCH;
1129    }
1130    }
1131  0 bpLocal += typeLength;
1132  0 if (charAt(bpLocal) != '"') {
1133  0 return NOT_MATCH;
1134    }
1135   
1136  0 this.ch = charAt(++bpLocal);
1137   
1138  0 if (ch == ',') {
1139  0 this.ch = charAt(++bpLocal);
1140  0 this.bp = bpLocal;
1141  0 token = JSONToken.COMMA;
1142  0 return VALUE;
1143  0 } else if (ch == '}') {
1144  0 ch = charAt(++bpLocal);
1145  0 if (ch == ',') {
1146  0 token = JSONToken.COMMA;
1147  0 this.ch = charAt(++bpLocal);
1148  0 } else if (ch == ']') {
1149  0 token = JSONToken.RBRACKET;
1150  0 this.ch = charAt(++bpLocal);
1151  0 } else if (ch == '}') {
1152  0 token = JSONToken.RBRACE;
1153  0 this.ch = charAt(++bpLocal);
1154  0 } else if (ch == EOI) {
1155  0 token = JSONToken.EOF;
1156    } else {
1157  0 return NOT_MATCH;
1158    }
1159  0 matchStat = END;
1160    }
1161   
1162  0 this.bp = bpLocal;
1163  0 return matchStat;
1164    }
1165   
 
1166  4114 toggle public final boolean matchField(char[] fieldName) {
1167  4114 for (;;) {
1168  4359 if (!charArrayCompare(fieldName)) {
1169  2799 if (isWhitespace(ch)) {
1170  245 next();
1171  245 continue;
1172    }
1173  2554 return false;
1174    } else {
1175  1560 break;
1176    }
1177    }
1178   
1179  1560 bp = bp + fieldName.length;
1180  1560 ch = charAt(bp);
1181   
1182  1560 if (ch == '{') {
1183  595 next();
1184  595 token = JSONToken.LBRACE;
1185  965 } else if (ch == '[') {
1186  508 next();
1187  508 token = JSONToken.LBRACKET;
1188  457 } else if (ch == 'S' && charAt(bp + 1) == 'e' && charAt(bp + 2) == 't' && charAt(bp + 3) == '[') {
1189  2 bp += 3;
1190  2 ch = charAt(bp);
1191  2 token = JSONToken.SET;
1192    } else {
1193  455 nextToken();
1194    }
1195   
1196  1560 return true;
1197    }
1198   
 
1199  0 toggle public int matchField(long fieldNameHash) {
1200  0 throw new UnsupportedOperationException();
1201    }
1202   
 
1203  0 toggle public boolean seekArrayToItem(int index) {
1204  0 throw new UnsupportedOperationException();
1205    }
1206   
 
1207  0 toggle public int seekObjectToField(long fieldNameHash, boolean deepScan) {
1208  0 throw new UnsupportedOperationException();
1209    }
1210   
 
1211  0 toggle public int seekObjectToField(long[] fieldNameHash) {
1212  0 throw new UnsupportedOperationException();
1213    }
1214   
 
1215  0 toggle public int seekObjectToFieldDeepScan(long fieldNameHash) {
1216  0 throw new UnsupportedOperationException();
1217    }
1218   
 
1219  0 toggle public void skipObject() {
1220  0 throw new UnsupportedOperationException();
1221    }
1222   
 
1223  0 toggle public void skipObject(boolean valid) {
1224  0 throw new UnsupportedOperationException();
1225    }
1226   
 
1227  0 toggle public void skipArray() {
1228  0 throw new UnsupportedOperationException();
1229    }
1230   
1231    public abstract int indexOf(char ch, int startIndex);
1232   
1233    public abstract String addSymbol(int offset, int len, int hash, final SymbolTable symbolTable);
1234   
 
1235  39 toggle public String scanFieldString(char[] fieldName) {
1236  39 matchStat = UNKNOWN;
1237   
1238  39 if (!charArrayCompare(fieldName)) {
1239  4 matchStat = NOT_MATCH_NAME;
1240  4 return stringDefaultValue();
1241    }
1242   
1243    // int index = bp + fieldName.length;
1244   
1245  35 int offset = fieldName.length;
1246  35 char chLocal = charAt(bp + (offset++));
1247   
1248  35 if (chLocal != '"') {
1249  1 matchStat = NOT_MATCH;
1250   
1251  1 return stringDefaultValue();
1252    }
1253   
1254  34 final String strVal;
1255    {
1256  34 int startIndex = bp + fieldName.length + 1;
1257  34 int endIndex = indexOf('"', startIndex);
1258  34 if (endIndex == -1) {
1259  1 throw new JSONException("unclosed str");
1260    }
1261   
1262  33 int startIndex2 = bp + fieldName.length + 1; // must re compute
1263  33 String stringVal = subString(startIndex2, endIndex - startIndex2);
1264  33 if (stringVal.indexOf('\\') != -1) {
1265  12 for (;;) {
1266  13 int slashCount = 0;
1267  14 for (int i = endIndex - 1; i >= 0; --i) {
1268  14 if (charAt(i) == '\\') {
1269  1 slashCount++;
1270    } else {
1271  13 break;
1272    }
1273    }
1274  13 if (slashCount % 2 == 0) {
1275  12 break;
1276    }
1277  1 endIndex = indexOf('"', endIndex + 1);
1278    }
1279   
1280  12 int chars_len = endIndex - (bp + fieldName.length + 1);
1281  12 char[] chars = sub_chars( bp + fieldName.length + 1, chars_len);
1282   
1283  12 stringVal = readString(chars, chars_len);
1284    }
1285   
1286  33 offset += (endIndex - (bp + fieldName.length + 1) + 1);
1287  33 chLocal = charAt(bp + (offset++));
1288  33 strVal = stringVal;
1289    }
1290   
1291  33 if (chLocal == ',') {
1292  5 bp += offset;
1293  5 this.ch = this.charAt(bp);
1294  5 matchStat = VALUE;
1295  5 return strVal;
1296    }
1297   
1298  28 if (chLocal == '}') {
1299  28 chLocal = charAt(bp + (offset++));
1300  28 if (chLocal == ',') {
1301  19 token = JSONToken.COMMA;
1302  19 bp += offset;
1303  19 this.ch = this.charAt(bp);
1304  9 } else if (chLocal == ']') {
1305  3 token = JSONToken.RBRACKET;
1306  3 bp += offset;
1307  3 this.ch = this.charAt(bp);
1308  6 } else if (chLocal == '}') {
1309  2 token = JSONToken.RBRACE;
1310  2 bp += offset;
1311  2 this.ch = this.charAt(bp);
1312  4 } else if (chLocal == EOI) {
1313  3 token = JSONToken.EOF;
1314  3 bp += (offset - 1);
1315  3 ch = EOI;
1316    } else {
1317  1 matchStat = NOT_MATCH;
1318  1 return stringDefaultValue();
1319    }
1320  27 matchStat = END;
1321    } else {
1322  0 matchStat = NOT_MATCH;
1323  0 return stringDefaultValue();
1324    }
1325   
1326  27 return strVal;
1327    }
1328   
 
1329  163 toggle public String scanString(char expectNextChar) {
1330  163 matchStat = UNKNOWN;
1331   
1332  163 int offset = 0;
1333  163 char chLocal = charAt(bp + (offset++));
1334   
1335  163 if (chLocal == 'n') {
1336  25 if (charAt(bp + offset) == 'u' && charAt(bp + offset + 1) == 'l' && charAt(bp + offset + 2) == 'l') {
1337  22 offset += 3;
1338  22 chLocal = charAt(bp + (offset++));
1339    } else {
1340  3 matchStat = NOT_MATCH;
1341  3 return null;
1342    }
1343   
1344  22 if (chLocal == expectNextChar) {
1345  19 bp += offset;
1346  19 this.ch = this.charAt(bp);
1347  19 matchStat = VALUE;
1348  19 return null;
1349    } else {
1350  3 matchStat = NOT_MATCH;
1351  3 return null;
1352    }
1353    }
1354   
1355  138 final String strVal;
1356  138 for (;;) {
1357  140 if (chLocal == '"') {
1358  102 int startIndex = bp + offset;
1359  102 int endIndex = indexOf('"', startIndex);
1360  102 if (endIndex == -1) {
1361  1 throw new JSONException("unclosed str");
1362    }
1363   
1364  101 String stringVal = subString(bp + offset, endIndex - startIndex);
1365  101 if (stringVal.indexOf('\\') != -1) {
1366  6 for (; ; ) {
1367  8 int slashCount = 0;
1368  10 for (int i = endIndex - 1; i >= 0; --i) {
1369  10 if (charAt(i) == '\\') {
1370  2 slashCount++;
1371    } else {
1372  8 break;
1373    }
1374    }
1375  8 if (slashCount % 2 == 0) {
1376  6 break;
1377    }
1378  2 endIndex = indexOf('"', endIndex + 1);
1379    }
1380   
1381  6 int chars_len = endIndex - startIndex;
1382  6 char[] chars = sub_chars(bp + 1, chars_len);
1383   
1384  6 stringVal = readString(chars, chars_len);
1385    }
1386   
1387  100 offset += (endIndex - startIndex + 1);
1388  100 chLocal = charAt(bp + (offset++));
1389  100 strVal = stringVal;
1390  100 break;
1391  38 } else if (isWhitespace(chLocal)) {
1392  2 chLocal = charAt(bp + (offset++));
1393  2 continue;
1394    } else {
1395  36 matchStat = NOT_MATCH;
1396   
1397  36 return stringDefaultValue();
1398    }
1399    }
1400   
1401  100 for (;;) {
1402  95 if (chLocal == expectNextChar) {
1403  95 bp += offset;
1404  95 this.ch = charAt(bp);
1405  95 matchStat = VALUE;
1406  95 token = JSONToken.COMMA;
1407  95 return strVal;
1408  0 } else if (isWhitespace(chLocal)) {
1409  0 chLocal = charAt(bp + (offset++));
1410  0 continue;
1411    } else {
1412  0 matchStat = NOT_MATCH;
1413  0 return strVal;
1414    }
1415    }
1416    }
1417   
 
1418  0 toggle public long scanFieldSymbol(char[] fieldName) {
1419  0 matchStat = UNKNOWN;
1420   
1421  0 if (!charArrayCompare(fieldName)) {
1422  0 matchStat = NOT_MATCH_NAME;
1423  0 return 0;
1424    }
1425   
1426  0 int offset = fieldName.length;
1427  0 char chLocal = charAt(bp + (offset++));
1428   
1429  0 if (chLocal != '"') {
1430  0 matchStat = NOT_MATCH;
1431  0 return 0;
1432    }
1433   
1434  0 long hash = 0xcbf29ce484222325L;
1435  0 for (;;) {
1436  0 chLocal = charAt(bp + (offset++));
1437  0 if (chLocal == '\"') {
1438  0 chLocal = charAt(bp + (offset++));
1439  0 break;
1440    }
1441   
1442  0 hash ^= chLocal;
1443  0 hash *= 0x100000001b3L;
1444   
1445  0 if (chLocal == '\\') {
1446  0 matchStat = NOT_MATCH;
1447  0 return 0;
1448    }
1449    }
1450   
1451  0 if (chLocal == ',') {
1452  0 bp += offset;
1453  0 this.ch = this.charAt(bp);
1454  0 matchStat = VALUE;
1455  0 return hash;
1456    }
1457   
1458  0 if (chLocal == '}') {
1459  0 chLocal = charAt(bp + (offset++));
1460  0 if (chLocal == ',') {
1461  0 token = JSONToken.COMMA;
1462  0 bp += offset;
1463  0 this.ch = this.charAt(bp);
1464  0 } else if (chLocal == ']') {
1465  0 token = JSONToken.RBRACKET;
1466  0 bp += offset;
1467  0 this.ch = this.charAt(bp);
1468  0 } else if (chLocal == '}') {
1469  0 token = JSONToken.RBRACE;
1470  0 bp += offset;
1471  0 this.ch = this.charAt(bp);
1472  0 } else if (chLocal == EOI) {
1473  0 token = JSONToken.EOF;
1474  0 bp += (offset - 1);
1475  0 ch = EOI;
1476    } else {
1477  0 matchStat = NOT_MATCH;
1478  0 return 0;
1479    }
1480  0 matchStat = END;
1481    } else {
1482  0 matchStat = NOT_MATCH;
1483  0 return 0;
1484    }
1485   
1486  0 return hash;
1487    }
1488   
 
1489  14415 toggle public long scanEnumSymbol(char[] fieldName) {
1490  14415 matchStat = UNKNOWN;
1491   
1492  14415 if (!charArrayCompare(fieldName)) {
1493  14 matchStat = NOT_MATCH_NAME;
1494  14 return 0;
1495    }
1496   
1497  14401 int offset = fieldName.length;
1498  14401 char chLocal = charAt(bp + (offset++));
1499   
1500  14401 if (chLocal != '"') {
1501  6146 matchStat = NOT_MATCH;
1502  6146 return 0;
1503    }
1504   
1505  8255 long hash = 0xcbf29ce484222325L;
1506  8255 for (;;) {
1507  16740 chLocal = charAt(bp + (offset++));
1508  16740 if (chLocal == '\"') {
1509  8254 chLocal = charAt(bp + (offset++));
1510  8254 break;
1511    }
1512   
1513  8486 hash ^= ((chLocal >= 'A' && chLocal <= 'Z') ? (chLocal + 32) : chLocal);
1514  8486 hash *= 0x100000001b3L;
1515   
1516  8486 if (chLocal == '\\') {
1517  1 matchStat = NOT_MATCH;
1518  1 return 0;
1519    }
1520    }
1521   
1522  8254 if (chLocal == ',') {
1523  10 bp += offset;
1524  10 this.ch = this.charAt(bp);
1525  10 matchStat = VALUE;
1526  10 return hash;
1527    }
1528   
1529  8244 if (chLocal == '}') {
1530  8239 chLocal = charAt(bp + (offset++));
1531  8239 if (chLocal == ',') {
1532  8196 token = JSONToken.COMMA;
1533  8196 bp += offset;
1534  8196 this.ch = this.charAt(bp);
1535  43 } else if (chLocal == ']') {
1536  6 token = JSONToken.RBRACKET;
1537  6 bp += offset;
1538  6 this.ch = this.charAt(bp);
1539  37 } else if (chLocal == '}') {
1540  9 token = JSONToken.RBRACE;
1541  9 bp += offset;
1542  9 this.ch = this.charAt(bp);
1543  28 } else if (chLocal == EOI) {
1544  26 token = JSONToken.EOF;
1545  26 bp += (offset - 1);
1546  26 ch = EOI;
1547    } else {
1548  2 matchStat = NOT_MATCH;
1549  2 return 0;
1550    }
1551  8237 matchStat = END;
1552    } else {
1553  5 matchStat = NOT_MATCH;
1554  5 return 0;
1555    }
1556   
1557  8237 return hash;
1558    }
1559   
 
1560  38 toggle @SuppressWarnings({ "unchecked", "rawtypes" })
1561    public Enum<?> scanEnum(Class<?> enumClass, final SymbolTable symbolTable, char serperator) {
1562  38 String name = scanSymbolWithSeperator(symbolTable, serperator);
1563  38 if (name == null) {
1564  20 return null;
1565    }
1566  18 return Enum.valueOf((Class<? extends Enum>) enumClass, name);
1567    }
1568   
 
1569  38 toggle public String scanSymbolWithSeperator(final SymbolTable symbolTable, char serperator) {
1570  38 matchStat = UNKNOWN;
1571   
1572  38 int offset = 0;
1573  38 char chLocal = charAt(bp + (offset++));
1574   
1575  38 if (chLocal == 'n') {
1576  14 if (charAt(bp + offset) == 'u' && charAt(bp + offset + 1) == 'l' && charAt(bp + offset + 2) == 'l') {
1577  8 offset += 3;
1578  8 chLocal = charAt(bp + (offset++));
1579    } else {
1580  6 matchStat = NOT_MATCH;
1581  6 return null;
1582    }
1583   
1584  8 if (chLocal == serperator) {
1585  4 bp += offset;
1586  4 this.ch = this.charAt(bp);
1587  4 matchStat = VALUE;
1588  4 return null;
1589    } else {
1590  4 matchStat = NOT_MATCH;
1591  4 return null;
1592    }
1593    }
1594   
1595  24 if (chLocal != '"') {
1596  6 matchStat = NOT_MATCH;
1597  6 return null;
1598    }
1599   
1600  18 String strVal;
1601    // int start = index;
1602  18 int hash = 0;
1603  18 for (;;) {
1604  56 chLocal = charAt(bp + (offset++));
1605  56 if (chLocal == '\"') {
1606    // bp = index;
1607    // this.ch = chLocal = charAt(bp);
1608  18 int start = bp + 0 + 1;
1609  18 int len = bp + offset - start - 1;
1610  18 strVal = addSymbol(start, len, hash, symbolTable);
1611  18 chLocal = charAt(bp + (offset++));
1612  18 break;
1613    }
1614   
1615  38 hash = 31 * hash + chLocal;
1616   
1617  38 if (chLocal == '\\') {
1618  0 matchStat = NOT_MATCH;
1619  0 return null;
1620    }
1621    }
1622   
1623  18 for (;;) {
1624  22 if (chLocal == serperator) {
1625  18 bp += offset;
1626  18 this.ch = this.charAt(bp);
1627  18 matchStat = VALUE;
1628  18 return strVal;
1629    } else {
1630  4 if (isWhitespace(chLocal)) {
1631  4 chLocal = charAt(bp + (offset++));
1632  4 continue;
1633    }
1634   
1635  0 matchStat = NOT_MATCH;
1636  0 return strVal;
1637    }
1638    }
1639    }
1640   
 
1641  0 toggle public Collection<String> newCollectionByType(Class<?> type){
1642  0 if (type.isAssignableFrom(HashSet.class)) {
1643  0 HashSet<String> list = new HashSet<String>();
1644  0 return list;
1645  0 } else if (type.isAssignableFrom(ArrayList.class)) {
1646  0 ArrayList<String> list2 = new ArrayList<String>();
1647  0 return list2;
1648    } else {
1649  0 try {
1650  0 Collection<String> list = (Collection<String>) type.newInstance();
1651  0 return list;
1652    } catch (Exception e) {
1653  0 throw new JSONException(e.getMessage(), e);
1654    }
1655    }
1656    }
1657   
 
1658  0 toggle @SuppressWarnings("unchecked")
1659    public Collection<String> scanFieldStringArray(char[] fieldName, Class<?> type) {
1660  0 matchStat = UNKNOWN;
1661   
1662  0 if (!charArrayCompare(fieldName)) {
1663  0 matchStat = NOT_MATCH_NAME;
1664  0 return null;
1665    }
1666   
1667  0 Collection<String> list = newCollectionByType(type);
1668   
1669    // if (type.isAssignableFrom(HashSet.class)) {
1670    // list = new HashSet<String>();
1671    // } else if (type.isAssignableFrom(ArrayList.class)) {
1672    // list = new ArrayList<String>();
1673    // } else {
1674    // try {
1675    // list = (Collection<String>) type.newInstance();
1676    // } catch (Exception e) {
1677    // throw new JSONException(e.getMessage(), e);
1678    // }
1679    // }
1680   
1681    // int index = bp + fieldName.length;
1682   
1683  0 int offset = fieldName.length;
1684  0 char chLocal = charAt(bp + (offset++));
1685   
1686  0 if (chLocal != '[') {
1687  0 matchStat = NOT_MATCH;
1688  0 return null;
1689    }
1690   
1691  0 chLocal = charAt(bp + (offset++));
1692   
1693  0 for (;;) {
1694    // int start = index;
1695  0 if (chLocal == '"') {
1696  0 int startIndex = bp + offset;
1697  0 int endIndex = indexOf('"', startIndex);
1698  0 if (endIndex == -1) {
1699  0 throw new JSONException("unclosed str");
1700    }
1701   
1702  0 int startIndex2 = bp + offset; // must re compute
1703  0 String stringVal = subString(startIndex2, endIndex - startIndex2);
1704  0 if (stringVal.indexOf('\\') != -1) {
1705  0 for (;;) {
1706  0 int slashCount = 0;
1707  0 for (int i = endIndex - 1; i >= 0; --i) {
1708  0 if (charAt(i) == '\\') {
1709  0 slashCount++;
1710    } else {
1711  0 break;
1712    }
1713    }
1714  0 if (slashCount % 2 == 0) {
1715  0 break;
1716    }
1717  0 endIndex = indexOf('"', endIndex + 1);
1718    }
1719   
1720  0 int chars_len = endIndex - (bp + offset);
1721  0 char[] chars = sub_chars(bp + offset, chars_len);
1722   
1723  0 stringVal = readString(chars, chars_len);
1724    }
1725   
1726  0 offset += (endIndex - (bp + offset) + 1);
1727  0 chLocal = charAt(bp + (offset++));
1728   
1729  0 list.add(stringVal);
1730  0 } else if (chLocal == 'n' //
1731    && charAt(bp + offset) == 'u' //
1732    && charAt(bp + offset + 1) == 'l' //
1733    && charAt(bp + offset + 2) == 'l') {
1734  0 offset += 3;
1735  0 chLocal = charAt(bp + (offset++));
1736  0 list.add(null);
1737  0 } else if (chLocal == ']' && list.size() == 0) {
1738  0 chLocal = charAt(bp + (offset++));
1739  0 break;
1740    } else {
1741  0 throw new JSONException("illega str");
1742    }
1743   
1744  0 if (chLocal == ',') {
1745  0 chLocal = charAt(bp + (offset++));
1746  0 continue;
1747    }
1748   
1749  0 if (chLocal == ']') {
1750  0 chLocal = charAt(bp + (offset++));
1751  0 break;
1752    }
1753   
1754  0 matchStat = NOT_MATCH;
1755  0 return null;
1756    }
1757   
1758  0 if (chLocal == ',') {
1759  0 bp += offset;
1760  0 this.ch = this.charAt(bp);
1761  0 matchStat = VALUE;
1762  0 return list;
1763    }
1764   
1765  0 if (chLocal == '}') {
1766  0 chLocal = charAt(bp + (offset++));
1767  0 if (chLocal == ',') {
1768  0 token = JSONToken.COMMA;
1769  0 bp += offset;
1770  0 this.ch = this.charAt(bp);
1771  0 } else if (chLocal == ']') {
1772  0 token = JSONToken.RBRACKET;
1773  0 bp += offset;
1774  0 this.ch = this.charAt(bp);
1775  0 } else if (chLocal == '}') {
1776  0 token = JSONToken.RBRACE;
1777  0 bp += offset;
1778  0 this.ch = this.charAt(bp);
1779  0 } else if (chLocal == EOI) {
1780  0 bp += (offset - 1);
1781  0 token = JSONToken.EOF;
1782  0 this.ch = EOI;
1783    } else {
1784  0 matchStat = NOT_MATCH;
1785  0 return null;
1786    }
1787  0 matchStat = END;
1788    } else {
1789  0 matchStat = NOT_MATCH;
1790  0 return null;
1791    }
1792   
1793  0 return list;
1794    }
1795   
 
1796  34 toggle public void scanStringArray(Collection<String> list, char seperator) {
1797  34 matchStat = UNKNOWN;
1798   
1799  34 int offset = 0;
1800  34 char chLocal = charAt(bp + (offset++));
1801   
1802  34 if (chLocal == 'n'
1803    && charAt(bp + offset) == 'u'
1804    && charAt(bp + offset + 1) == 'l'
1805    && charAt(bp + offset + 2) == 'l'
1806    && charAt(bp + offset + 3) == seperator
1807    ) {
1808  2 bp += 5;
1809  2 ch = charAt(bp);
1810  2 matchStat = VALUE_NULL;
1811  2 return;
1812    }
1813   
1814  32 if (chLocal != '[') {
1815  5 matchStat = NOT_MATCH;
1816  5 return;
1817    }
1818   
1819  27 chLocal = charAt(bp + (offset++));
1820   
1821  27 for (;;) {
1822  1043 if (chLocal == 'n' //
1823    && charAt(bp + offset) == 'u' //
1824    && charAt(bp + offset + 1) == 'l' //
1825    && charAt(bp + offset + 2) == 'l') {
1826  7 offset += 3;
1827  7 chLocal = charAt(bp + (offset++));
1828  7 list.add(null);
1829  1036 } else if (chLocal == ']' && list.size() == 0) {
1830  10 chLocal = charAt(bp + (offset++));
1831  10 break;
1832  1022 } else if (chLocal != '"') {
1833  0 matchStat = NOT_MATCH;
1834  0 return;
1835    } else {
1836  1022 int startIndex = bp + offset;
1837  1022 int endIndex = indexOf('"', startIndex);
1838  1022 if (endIndex == -1) {
1839  1 throw new JSONException("unclosed str");
1840    }
1841   
1842  1021 String stringVal = subString(bp + offset, endIndex - startIndex);
1843  1021 if (stringVal.indexOf('\\') != -1) {
1844  4 for (;;) {
1845  5 int slashCount = 0;
1846  6 for (int i = endIndex - 1; i >= 0; --i) {
1847  6 if (charAt(i) == '\\') {
1848  1 slashCount++;
1849    } else {
1850  5 break;
1851    }
1852    }
1853  5 if (slashCount % 2 == 0) {
1854  4 break;
1855    }
1856  1 endIndex = indexOf('"', endIndex + 1);
1857    }
1858   
1859  4 int chars_len = endIndex - startIndex;
1860  4 char[] chars = sub_chars(bp + offset, chars_len);
1861   
1862  4 stringVal = readString(chars, chars_len);
1863    }
1864   
1865  1021 offset += (endIndex - (bp + offset) + 1);
1866  1021 chLocal = charAt(bp + (offset++));
1867  1021 list.add(stringVal);
1868    }
1869   
1870  1028 if (chLocal == ',') {
1871  1016 chLocal = charAt(bp + (offset++));
1872  1016 continue;
1873    }
1874   
1875  10 if (chLocal == ']') {
1876  10 chLocal = charAt(bp + (offset++));
1877  10 break;
1878    }
1879   
1880  0 matchStat = NOT_MATCH;
1881  0 return;
1882    }
1883   
1884  20 if (chLocal == seperator) {
1885  18 bp += offset;
1886  18 this.ch = this.charAt(bp);
1887  18 matchStat = VALUE;
1888  18 return;
1889    } else {
1890  2 matchStat = NOT_MATCH;
1891  2 return;
1892    }
1893    }
1894   
 
1895  1059 toggle public int scanFieldInt(char[] fieldName) {
1896  1059 matchStat = UNKNOWN;
1897   
1898  1059 if (!charArrayCompare(fieldName)) {
1899  3 matchStat = NOT_MATCH_NAME;
1900  3 return 0;
1901    }
1902   
1903  1056 int offset = fieldName.length;
1904  1056 char chLocal = charAt(bp + (offset++));
1905   
1906  1056 final boolean negative = chLocal == '-';
1907  1056 if (negative) {
1908  14 chLocal = charAt(bp + (offset++));
1909    }
1910   
1911  1056 int value;
1912  1056 if (chLocal >= '0' && chLocal <= '9') {
1913  1055 value = chLocal - '0';
1914  1055 for (;;) {
1915  3132 chLocal = charAt(bp + (offset++));
1916  3132 if (chLocal >= '0' && chLocal <= '9') {
1917  2077 value = value * 10 + (chLocal - '0');
1918  1055 } else if (chLocal == '.') {
1919  1 matchStat = NOT_MATCH;
1920  1 return 0;
1921    } else {
1922  1054 break;
1923    }
1924    }
1925  1054 if (value < 0 //
1926    || offset > 11 + 3 + fieldName.length) {
1927  4 if (value != Integer.MIN_VALUE //
1928    || offset != 17 //
1929    || !negative) {
1930  3 matchStat = NOT_MATCH;
1931  3 return 0;
1932    }
1933    }
1934    } else {
1935  1 matchStat = NOT_MATCH;
1936  1 return 0;
1937    }
1938   
1939  1051 if (chLocal == ',') {
1940  10 bp += offset;
1941  10 this.ch = this.charAt(bp);
1942  10 matchStat = VALUE;
1943  10 token = JSONToken.COMMA;
1944  10 return negative ? -value : value;
1945    }
1946   
1947  1041 if (chLocal == '}') {
1948  1038 chLocal = charAt(bp + (offset++));
1949  1038 if (chLocal == ',') {
1950  1024 token = JSONToken.COMMA;
1951  1024 bp += offset;
1952  1024 this.ch = this.charAt(bp);
1953  14 } else if (chLocal == ']') {
1954  6 token = JSONToken.RBRACKET;
1955  6 bp += offset;
1956  6 this.ch = this.charAt(bp);
1957  8 } else if (chLocal == '}') {
1958  2 token = JSONToken.RBRACE;
1959  2 bp += offset;
1960  2 this.ch = this.charAt(bp);
1961  6 } else if (chLocal == EOI) {
1962  3 token = JSONToken.EOF;
1963  3 bp += (offset - 1);
1964  3 ch = EOI;
1965    } else {
1966  3 matchStat = NOT_MATCH;
1967  3 return 0;
1968    }
1969  1035 matchStat = END;
1970    } else {
1971  3 matchStat = NOT_MATCH;
1972  3 return 0;
1973    }
1974   
1975  1035 return negative ? -value : value;
1976    }
1977   
 
1978  9 toggle public final int[] scanFieldIntArray(char[] fieldName) {
1979  9 matchStat = UNKNOWN;
1980   
1981  9 if (!charArrayCompare(fieldName)) {
1982  0 matchStat = NOT_MATCH_NAME;
1983  0 return null;
1984    }
1985   
1986  9 int offset = fieldName.length;
1987  9 char chLocal = charAt(bp + (offset++));
1988   
1989  9 if (chLocal != '[') {
1990  1 matchStat = NOT_MATCH_NAME;
1991  1 return null;
1992    }
1993  8 chLocal = charAt(bp + (offset++));
1994   
1995  8 int[] array = new int[16];
1996  8 int arrayIndex = 0;
1997   
1998  8 if (chLocal == ']') {
1999  0 chLocal = charAt(bp + (offset++));
2000    } else {
2001  8 for (;;) {
2002  18 boolean nagative = false;
2003  18 if (chLocal == '-') {
2004  0 chLocal = charAt(bp + (offset++));
2005  0 nagative = true;
2006    }
2007  18 if (chLocal >= '0' && chLocal <= '9') {
2008  17 int value = chLocal - '0';
2009  17 for (; ; ) {
2010  37 chLocal = charAt(bp + (offset++));
2011   
2012  37 if (chLocal >= '0' && chLocal <= '9') {
2013  20 value = value * 10 + (chLocal - '0');
2014    } else {
2015  17 break;
2016    }
2017    }
2018   
2019  17 if (arrayIndex >= array.length) {
2020  0 int[] tmp = new int[array.length * 3 / 2];
2021  0 System.arraycopy(array, 0, tmp, 0, arrayIndex);
2022  0 array = tmp;
2023    }
2024  17 array[arrayIndex++] = nagative ? -value : value;
2025   
2026  17 if (chLocal == ',') {
2027  10 chLocal = charAt(bp + (offset++));
2028  7 } else if (chLocal == ']') {
2029  7 chLocal = charAt(bp + (offset++));
2030  7 break;
2031    }
2032    } else {
2033  1 matchStat = NOT_MATCH;
2034  1 return null;
2035    }
2036    }
2037    }
2038   
2039   
2040  7 if (arrayIndex != array.length) {
2041  7 int[] tmp = new int[arrayIndex];
2042  7 System.arraycopy(array, 0, tmp, 0, arrayIndex);
2043  7 array = tmp;
2044    }
2045   
2046  7 if (chLocal == ',') {
2047  0 bp += (offset - 1);
2048  0 this.next();
2049  0 matchStat = VALUE;
2050  0 token = JSONToken.COMMA;
2051  0 return array;
2052    }
2053   
2054  7 if (chLocal == '}') {
2055  7 chLocal = charAt(bp + (offset++));
2056  7 if (chLocal == ',') {
2057  3 token = JSONToken.COMMA;
2058  3 bp += (offset - 1);
2059  3 this.next();
2060  4 } else if (chLocal == ']') {
2061  2 token = JSONToken.RBRACKET;
2062  2 bp += (offset - 1);
2063  2 this.next();
2064  2 } else if (chLocal == '}') {
2065  0 token = JSONToken.RBRACE;
2066  0 bp += (offset - 1);
2067  0 this.next();
2068  2 } else if (chLocal == EOI) {
2069  2 bp += (offset - 1);
2070  2 token = JSONToken.EOF;
2071  2 ch = EOI;
2072    } else {
2073  0 matchStat = NOT_MATCH;
2074  0 return null;
2075    }
2076  7 matchStat = END;
2077    } else {
2078  0 matchStat = NOT_MATCH;
2079  0 return null;
2080    }
2081   
2082  7 return array;
2083    }
2084   
 
2085  35 toggle public boolean scanBoolean(char expectNext) {
2086  35 matchStat = UNKNOWN;
2087   
2088  35 int offset = 0;
2089  35 char chLocal = charAt(bp + (offset++));
2090   
2091  35 boolean value = false;
2092  35 if (chLocal == 't') {
2093  15 if (charAt(bp + offset) == 'r' //
2094    && charAt(bp + offset + 1) == 'u' //
2095    && charAt(bp + offset + 2) == 'e') {
2096  7 offset += 3;
2097  7 chLocal = charAt(bp + (offset++));
2098  7 value = true;
2099    } else {
2100  8 matchStat = NOT_MATCH;
2101  8 return false;
2102    }
2103  20 } else if (chLocal == 'f') {
2104  18 if (charAt(bp + offset) == 'a' //
2105    && charAt(bp + offset + 1) == 'l' //
2106    && charAt(bp + offset + 2) == 's' //
2107    && charAt(bp + offset + 3) == 'e') {
2108  10 offset += 4;
2109  10 chLocal = charAt(bp + (offset++));
2110  10 value = false;
2111    } else {
2112  8 matchStat = NOT_MATCH;
2113  8 return false;
2114    }
2115  2 } else if (chLocal == '1') {
2116  1 chLocal = charAt(bp + (offset++));
2117  1 value = true;
2118  1 } else if (chLocal == '0') {
2119  1 chLocal = charAt(bp + (offset++));
2120  1 value = false;
2121    }
2122   
2123  19 for (;;) {
2124  21 if (chLocal == expectNext) {
2125  15 bp += offset;
2126  15 this.ch = this.charAt(bp);
2127  15 matchStat = VALUE;
2128  15 return value;
2129    } else {
2130  6 if (isWhitespace(chLocal)) {
2131  2 chLocal = charAt(bp + (offset++));
2132  2 continue;
2133    }
2134  4 matchStat = NOT_MATCH;
2135  4 return value;
2136    }
2137    }
2138    }
2139   
 
2140  16 toggle public int scanInt(char expectNext) {
2141  16 matchStat = UNKNOWN;
2142   
2143  16 int offset = 0;
2144  16 char chLocal = charAt(bp + (offset++));
2145   
2146  16 final boolean quote = chLocal == '"';
2147  16 if (quote) {
2148  2 chLocal = charAt(bp + (offset++));
2149    }
2150   
2151  16 final boolean negative = chLocal == '-';
2152  16 if (negative) {
2153  2 chLocal = charAt(bp + (offset++));
2154    }
2155   
2156  16 int value;
2157  16 if (chLocal >= '0' && chLocal <= '9') {
2158  10 value = chLocal - '0';
2159  10 for (;;) {
2160  29 chLocal = charAt(bp + (offset++));
2161  29 if (chLocal >= '0' && chLocal <= '9') {
2162  19 value = value * 10 + (chLocal - '0');
2163  9 } else if (chLocal == '.') {
2164  0 matchStat = NOT_MATCH;
2165  0 return 0;
2166    } else {
2167  9 break;
2168    }
2169    }
2170  8 if (value < 0) {
2171  0 matchStat = NOT_MATCH;
2172  0 return 0;
2173    }
2174  4 } else if (chLocal == 'n' && charAt(bp + offset) == 'u' && charAt(bp + offset + 1) == 'l' && charAt(bp + offset + 2) == 'l') {
2175  4 matchStat = VALUE_NULL;
2176  4 value = 0;
2177  4 offset += 3;
2178  4 chLocal = charAt(bp + offset++);
2179   
2180  4 if (quote && chLocal == '"') {
2181  2 chLocal = charAt(bp + offset++);
2182    }
2183   
2184  4 for (;;) {
2185  6 if (chLocal == ',') {
2186  2 bp += offset;
2187  2 this.ch = charAt(bp);
2188  2 matchStat = VALUE_NULL;
2189  2 token = JSONToken.COMMA;
2190  2 return value;
2191  4 } else if (chLocal == ']') {
2192  2 bp += offset;
2193  2 this.ch = charAt(bp);
2194  2 matchStat = VALUE_NULL;
2195  2 token = JSONToken.RBRACKET;
2196  2 return value;
2197  2 } else if (isWhitespace(chLocal)) {
2198  2 chLocal = charAt(bp + offset++);
2199  2 continue;
2200    }
2201  0 break;
2202    }
2203  0 matchStat = NOT_MATCH;
2204  0 return 0;
2205    } else {
2206  0 matchStat = NOT_MATCH;
2207  0 return 0;
2208    }
2209   
2210  8 for (;;) {
2211  10 if (chLocal == expectNext) {
2212  6 bp += offset;
2213  6 this.ch = this.charAt(bp);
2214  6 matchStat = VALUE;
2215  6 token = JSONToken.COMMA;
2216  6 return negative ? -value : value;
2217    } else {
2218  2 if (isWhitespace(chLocal)) {
2219  2 chLocal = charAt(bp + (offset++));
2220  2 continue;
2221    }
2222  0 matchStat = NOT_MATCH;
2223  0 return negative ? -value : value;
2224    }
2225    }
2226    }
2227   
 
2228  35 toggle public boolean scanFieldBoolean(char[] fieldName) {
2229  35 matchStat = UNKNOWN;
2230   
2231  35 if (!charArrayCompare(fieldName)) {
2232  4 matchStat = NOT_MATCH_NAME;
2233  4 return false;
2234    }
2235   
2236  31 int offset = fieldName.length;
2237  31 char chLocal = charAt(bp + (offset++));
2238   
2239  31 boolean value;
2240  31 if (chLocal == 't') {
2241  11 if (charAt(bp + (offset++)) != 'r') {
2242  1 matchStat = NOT_MATCH;
2243  1 return false;
2244    }
2245  10 if (charAt(bp + (offset++)) != 'u') {
2246  1 matchStat = NOT_MATCH;
2247  1 return false;
2248    }
2249  9 if (charAt(bp + (offset++)) != 'e') {
2250  1 matchStat = NOT_MATCH;
2251  1 return false;
2252    }
2253   
2254  8 value = true;
2255  20 } else if (chLocal == 'f') {
2256  12 if (charAt(bp + (offset++)) != 'a') {
2257  1 matchStat = NOT_MATCH;
2258  1 return false;
2259    }
2260  11 if (charAt(bp + (offset++)) != 'l') {
2261  1 matchStat = NOT_MATCH;
2262  1 return false;
2263    }
2264  10 if (charAt(bp + (offset++)) != 's') {
2265  1 matchStat = NOT_MATCH;
2266  1 return false;
2267    }
2268  9 if (charAt(bp + (offset++)) != 'e') {
2269  1 matchStat = NOT_MATCH;
2270  1 return false;
2271    }
2272   
2273  8 value = false;
2274    } else {
2275  8 matchStat = NOT_MATCH;
2276  8 return false;
2277    }
2278   
2279  16 chLocal = charAt(bp + offset++);
2280  16 if (chLocal == ',') {
2281  3 bp += offset;
2282  3 this.ch = this.charAt(bp);
2283  3 matchStat = VALUE;
2284  3 token = JSONToken.COMMA;
2285   
2286  3 return value;
2287    }
2288   
2289  13 if (chLocal == '}') {
2290  13 chLocal = charAt(bp + (offset++));
2291  13 if (chLocal == ',') {
2292  9 token = JSONToken.COMMA;
2293  9 bp += offset;
2294  9 this.ch = this.charAt(bp);
2295  4 } else if (chLocal == ']') {
2296  1 token = JSONToken.RBRACKET;
2297  1 bp += offset;
2298  1 this.ch = this.charAt(bp);
2299  3 } else if (chLocal == '}') {
2300  1 token = JSONToken.RBRACE;
2301  1 bp += offset;
2302  1 this.ch = this.charAt(bp);
2303  2 } else if (chLocal == EOI) {
2304  1 token = JSONToken.EOF;
2305  1 bp += (offset - 1);
2306  1 ch = EOI;
2307    } else {
2308  1 matchStat = NOT_MATCH;
2309  1 return false;
2310    }
2311  12 matchStat = END;
2312    } else {
2313  0 matchStat = NOT_MATCH;
2314  0 return false;
2315    }
2316   
2317  12 return value;
2318    }
2319   
 
2320  12215 toggle public long scanFieldLong(char[] fieldName) {
2321  12215 matchStat = UNKNOWN;
2322   
2323  12215 if (!charArrayCompare(fieldName)) {
2324  274 matchStat = NOT_MATCH_NAME;
2325  274 return 0;
2326    }
2327   
2328  11941 int offset = fieldName.length;
2329  11941 char chLocal = charAt(bp + (offset++));
2330   
2331  11941 boolean negative = false;
2332  11941 if (chLocal == '-') {
2333  7858 chLocal = charAt(bp + (offset++));
2334  7858 negative = true;
2335    }
2336   
2337  11941 long value;
2338  11941 if (chLocal >= '0' && chLocal <= '9') {
2339  11928 value = chLocal - '0';
2340  11928 for (;;) {
2341  225491 chLocal = charAt(bp + (offset++));
2342  225491 if (chLocal >= '0' && chLocal <= '9') {
2343  213563 value = value * 10 + (chLocal - '0');
2344  11928 } else if (chLocal == '.') {
2345  1 matchStat = NOT_MATCH;
2346  1 return 0;
2347    } else {
2348  11927 break;
2349    }
2350    }
2351   
2352  11927 boolean valid = offset - fieldName.length < 21
2353    && (value >= 0 || (value == -9223372036854775808L && negative));
2354  11927 if (!valid) {
2355  7407 matchStat = NOT_MATCH;
2356  7407 return 0;
2357    }
2358    } else {
2359  13 matchStat = NOT_MATCH;
2360  13 return 0;
2361    }
2362   
2363  4520 if (chLocal == ',') {
2364  8 bp += offset;
2365  8 this.ch = this.charAt(bp);
2366  8 matchStat = VALUE;
2367  8 token = JSONToken.COMMA;
2368  8 return negative ? -value : value;
2369    }
2370   
2371  4512 if (chLocal == '}') {
2372  4511 chLocal = charAt(bp + (offset++));
2373  4511 if (chLocal == ',') {
2374  4506 token = JSONToken.COMMA;
2375  4506 bp += offset;
2376  4506 this.ch = this.charAt(bp);
2377  5 } else if (chLocal == ']') {
2378  1 token = JSONToken.RBRACKET;
2379  1 bp += offset;
2380  1 this.ch = this.charAt(bp);
2381  4 } else if (chLocal == '}') {
2382  1 token = JSONToken.RBRACE;
2383  1 bp += offset;
2384  1 this.ch = this.charAt(bp);
2385  3 } else if (chLocal == EOI) {
2386  2 token = JSONToken.EOF;
2387  2 bp += (offset - 1);
2388  2 ch = EOI;
2389    } else {
2390  1 matchStat = NOT_MATCH;
2391  1 return 0;
2392    }
2393  4510 matchStat = END;
2394    } else {
2395  1 matchStat = NOT_MATCH;
2396  1 return 0;
2397    }
2398   
2399  4510 return negative ? -value : value;
2400    }
2401   
 
2402  2087 toggle public long scanLong(char expectNextChar) {
2403  2087 matchStat = UNKNOWN;
2404   
2405  2087 int offset = 0;
2406  2087 char chLocal = charAt(bp + (offset++));
2407  2087 final boolean quote = chLocal == '"';
2408  2087 if (quote) {
2409  12 chLocal = charAt(bp + (offset++));
2410    }
2411   
2412  2087 final boolean negative = chLocal == '-';
2413  2087 if (negative) {
2414  1047 chLocal = charAt(bp + (offset++));
2415    }
2416   
2417  2087 long value;
2418  2087 if (chLocal >= '0' && chLocal <= '9') {
2419  2081 value = chLocal - '0';
2420  2081 for (;;) {
2421  39199 chLocal = charAt(bp + (offset++));
2422  39199 if (chLocal >= '0' && chLocal <= '9') {
2423  37118 value = value * 10 + (chLocal - '0');
2424  2080 } else if (chLocal == '.') {
2425  0 matchStat = NOT_MATCH;
2426  0 return 0;
2427    } else {
2428  2080 break;
2429    }
2430    }
2431  2080 boolean valid = value >= 0 || (value == -9223372036854775808L && negative);
2432  2080 if (!valid) {
2433  1 String val = subString(bp, offset - 1);
2434  1 throw new NumberFormatException(val);
2435    }
2436  4 } else if (chLocal == 'n' && charAt(bp + offset) == 'u' && charAt(bp + offset + 1) == 'l' && charAt(bp + offset + 2) == 'l') {
2437  4 matchStat = VALUE_NULL;
2438  4 value = 0;
2439  4 offset += 3;
2440  4 chLocal = charAt(bp + offset++);
2441   
2442  4 if (quote && chLocal == '"') {
2443  2 chLocal = charAt(bp + offset++);
2444    }
2445   
2446  4 for (;;) {
2447  6 if (chLocal == ',') {
2448  2 bp += offset;
2449  2 this.ch = charAt(bp);
2450  2 matchStat = VALUE_NULL;
2451  2 token = JSONToken.COMMA;
2452  2 return value;
2453  4 } else if (chLocal == ']') {
2454  2 bp += offset;
2455  2 this.ch = charAt(bp);
2456  2 matchStat = VALUE_NULL;
2457  2 token = JSONToken.RBRACKET;
2458  2 return value;
2459  2 } else if (isWhitespace(chLocal)) {
2460  2 chLocal = charAt(bp + offset++);
2461  2 continue;
2462    }
2463  0 break;
2464    }
2465  0 matchStat = NOT_MATCH;
2466  0 return 0;
2467    } else {
2468  0 matchStat = NOT_MATCH;
2469  0 return 0;
2470    }
2471   
2472  2079 if (quote) {
2473  10 if (chLocal != '"') {
2474  0 matchStat = NOT_MATCH;
2475  0 return 0;
2476    } else {
2477  10 chLocal = charAt(bp + (offset++));
2478    }
2479    }
2480   
2481  2079 for (;;) {
2482  2081 if (chLocal == expectNextChar) {
2483  2076 bp += offset;
2484  2076 this.ch = this.charAt(bp);
2485  2076 matchStat = VALUE;
2486  2076 token = JSONToken.COMMA;
2487  2076 return negative ? -value : value;
2488    } else {
2489  2 if (isWhitespace(chLocal)) {
2490  2 chLocal = charAt(bp + (offset++));
2491  2 continue;
2492    }
2493   
2494  0 matchStat = NOT_MATCH;
2495  0 return value;
2496    }
2497    }
2498    }
2499   
 
2500  1001187 toggle public final float scanFieldFloat(char[] fieldName) {
2501  1001187 matchStat = UNKNOWN;
2502   
2503  1001187 if (!charArrayCompare(fieldName)) {
2504  76 matchStat = NOT_MATCH_NAME;
2505  76 return 0;
2506    }
2507   
2508  1001111 int offset = fieldName.length;
2509  1001111 char chLocal = charAt(bp + (offset++));
2510   
2511  1001111 final boolean quote = chLocal == '"';
2512  1001111 if (quote) {
2513  25 chLocal = charAt(bp + (offset++));
2514    }
2515   
2516  1001111 boolean negative = chLocal == '-';
2517  1001111 if (negative) {
2518  4 chLocal = charAt(bp + (offset++));
2519    }
2520   
2521  1001111 float value;
2522  1001111 if (chLocal >= '0' && chLocal <= '9') {
2523  1001085 long intVal = chLocal - '0';
2524  1001085 for (;;) {
2525  1003097 chLocal = charAt(bp + (offset++));
2526  1003097 if (chLocal >= '0' && chLocal <= '9') {
2527  2012 intVal = intVal * 10 + (chLocal - '0');
2528  2012 continue;
2529    } else {
2530  1001085 break;
2531    }
2532    }
2533   
2534  1001085 long power = 1;
2535  1001085 boolean small = (chLocal == '.');
2536  1001085 if (small) {
2537  1001075 chLocal = charAt(bp + (offset++));
2538  1001075 if (chLocal >= '0' && chLocal <= '9') {
2539  1001071 intVal = intVal * 10 + (chLocal - '0');
2540  1001071 power = 10;
2541  1001071 for (;;) {
2542  7625154 chLocal = charAt(bp + (offset++));
2543  7625154 if (chLocal >= '0' && chLocal <= '9') {
2544  6624083 intVal = intVal * 10 + (chLocal - '0');
2545  6624083 power *= 10;
2546  6624083 continue;
2547    } else {
2548  1001071 break;
2549    }
2550    }
2551    } else {
2552  4 matchStat = NOT_MATCH;
2553  4 return 0;
2554    }
2555    }
2556   
2557  1001081 boolean exp = chLocal == 'e' || chLocal == 'E';
2558  1001081 if (exp) {
2559  1018 chLocal = charAt(bp + (offset++));
2560  1018 if (chLocal == '+' || chLocal == '-') {
2561  1016 chLocal = charAt(bp + (offset++));
2562    }
2563  1018 for (;;) {
2564  2039 if (chLocal >= '0' && chLocal <= '9') {
2565  1021 chLocal = charAt(bp + (offset++));
2566    } else {
2567  1018 break;
2568    }
2569    }
2570    }
2571   
2572  1001081 int start, count;
2573  1001081 if (quote) {
2574  14 if (chLocal != '"') {
2575  0 matchStat = NOT_MATCH;
2576  0 return 0;
2577    } else {
2578  14 chLocal = charAt(bp + (offset++));
2579    }
2580  14 start = bp + fieldName.length + 1;
2581  14 count = bp + offset - start - 2;
2582    } else {
2583  1001067 start = bp + fieldName.length;
2584  1001067 count = bp + offset - start - 1;
2585    }
2586   
2587  1001081 if ((!exp) && count < 17) {
2588  1000060 value = (float) (((double) intVal) / power);
2589  1000060 if (negative) {
2590  4 value = -value;
2591    }
2592    } else {
2593  1021 String text = this.subString(start, count);
2594  1021 value = Float.parseFloat(text);
2595    }
2596  26 } else if (chLocal == 'n' && charAt(bp + offset) == 'u' && charAt(bp + offset + 1) == 'l' && charAt(bp + offset + 2) == 'l') {
2597  19 matchStat = VALUE_NULL;
2598  19 value = 0;
2599  19 offset += 3;
2600  19 chLocal = charAt(bp + offset++);
2601   
2602  19 if (quote && chLocal == '"') {
2603  7 chLocal = charAt(bp + offset++);
2604    }
2605   
2606  19 for (;;) {
2607  26 if (chLocal == ',') {
2608  7 bp += offset;
2609  7 this.ch = charAt(bp);
2610  7 matchStat = VALUE_NULL;
2611  7 token = JSONToken.COMMA;
2612  7 return value;
2613  19 } else if (chLocal == '}') {
2614  12 bp += offset;
2615  12 this.ch = charAt(bp);
2616  12 matchStat = VALUE_NULL;
2617  12 token = JSONToken.RBRACE;
2618  12 return value;
2619  7 } else if (isWhitespace(chLocal)) {
2620  7 chLocal = charAt(bp + offset++);
2621  7 continue;
2622    }
2623  0 break;
2624    }
2625  0 matchStat = NOT_MATCH;
2626  0 return 0;
2627    } else {
2628  7 matchStat = NOT_MATCH;
2629  7 return 0;
2630    }
2631   
2632  1001081 if (chLocal == ',') {
2633  27 bp += offset;
2634  27 this.ch = this.charAt(bp);
2635  27 matchStat = VALUE;
2636  27 token = JSONToken.COMMA;
2637  27 return value;
2638    }
2639   
2640  1001054 if (chLocal == '}') {
2641  1001046 chLocal = charAt(bp + (offset++));
2642  1001046 if (chLocal == ',') {
2643  1024 token = JSONToken.COMMA;
2644  1024 bp += offset;
2645  1024 this.ch = this.charAt(bp);
2646  1000022 } else if (chLocal == ']') {
2647  2 token = JSONToken.RBRACKET;
2648  2 bp += offset;
2649  2 this.ch = this.charAt(bp);
2650  1000019 } else if (chLocal == '}') {
2651  0 token = JSONToken.RBRACE;
2652  0 bp += offset;
2653  0 this.ch = this.charAt(bp);
2654  1000018 } else if (chLocal == EOI) {
2655  1000018 bp += (offset - 1);
2656  1000018 token = JSONToken.EOF;
2657  1000018 ch = EOI;
2658    } else {
2659  0 matchStat = NOT_MATCH;
2660  0 return 0;
2661    }
2662  1001045 matchStat = END;
2663    } else {
2664  8 matchStat = NOT_MATCH;
2665  8 return 0;
2666    }
2667   
2668  1001045 return value;
2669    }
2670   
 
2671  1000037 toggle public final float scanFloat(char seperator) {
2672  1000037 matchStat = UNKNOWN;
2673   
2674  1000037 int offset = 0;
2675  1000037 char chLocal = charAt(bp + (offset++));
2676  1000037 final boolean quote = chLocal == '"';
2677  1000037 if (quote) {
2678  18 chLocal = charAt(bp + (offset++));
2679    }
2680   
2681  1000037 boolean negative = chLocal == '-';
2682  1000037 if (negative) {
2683  4 chLocal = charAt(bp + (offset++));
2684    }
2685   
2686  1000037 float value;
2687  1000037 if (chLocal >= '0' && chLocal <= '9') {
2688  1000031 long intVal = chLocal - '0';
2689  1000031 for (; ; ) {
2690  1000045 chLocal = charAt(bp + (offset++));
2691  1000045 if (chLocal >= '0' && chLocal <= '9') {
2692  14 intVal = intVal * 10 + (chLocal - '0');
2693  14 continue;
2694    } else {
2695  1000031 break;
2696    }
2697    }
2698   
2699  1000031 long power = 1;
2700  1000031 boolean small = (chLocal == '.');
2701  1000029 if (small) {
2702  1000029 chLocal = charAt(bp + (offset++));
2703  1000027 if (chLocal >= '0' && chLocal <= '9') {
2704  1000027 intVal = intVal * 10 + (chLocal - '0');
2705  1000027 power = 10;
2706  1000027 for (; ; ) {
2707  7622517 chLocal = charAt(bp + (offset++));
2708  7622517 if (chLocal >= '0' && chLocal <= '9') {
2709  6622490 intVal = intVal * 10 + (chLocal - '0');
2710  6622490 power *= 10;
2711  6622490 continue;
2712    } else {
2713  1000027 break;
2714    }
2715    }
2716    } else {
2717  0 matchStat = NOT_MATCH;
2718  0 return 0;
2719    }
2720    }
2721   
2722  1000029 boolean exp = chLocal == 'e' || chLocal == 'E';
2723  1000029 if (exp) {
2724  1051 chLocal = charAt(bp + (offset++));
2725  1051 if (chLocal == '+' || chLocal == '-') {
2726  1051 chLocal = charAt(bp + (offset++));
2727    }
2728  1051 for (; ; ) {
2729  2102 if (chLocal >= '0' && chLocal <= '9') {
2730  1051 chLocal = charAt(bp + (offset++));
2731    } else {
2732  1051 break;
2733    }
2734    }
2735    }
2736    // int start, count;
2737    // if (quote) {
2738    // if (chLocal != '"') {
2739    // matchStat = NOT_MATCH;
2740    // return 0;
2741    // } else {
2742    // chLocal = charAt(bp + (offset++));
2743    // }
2744    // start = bp + 1;
2745    // count = bp + offset - start - 2;
2746    // } else {
2747    // start = bp;
2748    // count = bp + offset - start - 1;
2749    // }
2750    // String text = this.subString(start, count);
2751    // value = Float.parseFloat(text);
2752  1000029 int start, count;
2753  1000029 if (quote) {
2754  12 if (chLocal != '"') {
2755  0 matchStat = NOT_MATCH;
2756  0 return 0;
2757    } else {
2758  12 chLocal = charAt(bp + (offset++));
2759    }
2760  12 start = bp + 1;
2761  12 count = bp + offset - start - 2;
2762    } else {
2763  1000017 start = bp;
2764  1000017 count = bp + offset - start - 1;
2765    }
2766   
2767  1000029 if ((!exp) && count < 17) {
2768  998977 value = (float) (((double) intVal) / power);
2769  998977 if (negative) {
2770  4 value = -value;
2771    }
2772    } else {
2773  1052 String text = this.subString(start, count);
2774  1052 value = Float.parseFloat(text);
2775    }
2776  4 } else if (chLocal == 'n' && charAt(bp + offset) == 'u' && charAt(bp + offset + 1) == 'l' && charAt(bp + offset + 2) == 'l') {
2777  4 matchStat = VALUE_NULL;
2778  4 value = 0;
2779  4 offset += 3;
2780  4 chLocal = charAt(bp + offset++);
2781   
2782  4 if (quote && chLocal == '"') {
2783  4 chLocal = charAt(bp + offset++);
2784    }
2785   
2786  4 for (;;) {
2787  6 if (chLocal == ',') {
2788  2 bp += offset;
2789  2 this.ch = charAt(bp);
2790  2 matchStat = VALUE_NULL;
2791  2 token = JSONToken.COMMA;
2792  2 return value;
2793  4 } else if (chLocal == ']') {
2794  2 bp += offset;
2795  2 this.ch = charAt(bp);
2796  2 matchStat = VALUE_NULL;
2797  2 token = JSONToken.RBRACKET;
2798  2 return value;
2799  2 } else if (isWhitespace(chLocal)) {
2800  2 chLocal = charAt(bp + offset++);
2801  2 continue;
2802    }
2803  0 break;
2804    }
2805  0 matchStat = NOT_MATCH;
2806  0 return 0;
2807    } else {
2808  0 matchStat = NOT_MATCH;
2809  0 return 0;
2810    }
2811   
2812  1000027 if (chLocal == seperator) {
2813  1000027 bp += offset;
2814  1000027 this.ch = this.charAt(bp);
2815  1000027 matchStat = VALUE;
2816  1000027 token = JSONToken.COMMA;
2817  1000027 return value;
2818    } else {
2819  0 matchStat = NOT_MATCH;
2820  0 return value;
2821    }
2822    }
2823   
 
2824  2 toggle public double scanDouble(char seperator) {
2825  2 matchStat = UNKNOWN;
2826   
2827  2 int offset = 0;
2828  2 char chLocal = charAt(bp + (offset++));
2829  2 final boolean quote = chLocal == '"';
2830  2 if (quote) {
2831  2 chLocal = charAt(bp + (offset++));
2832    }
2833   
2834  2 boolean negative = chLocal == '-';
2835  2 if (negative) {
2836  0 chLocal = charAt(bp + (offset++));
2837    }
2838   
2839  2 double value;
2840  2 if (chLocal >= '0' && chLocal <= '9') {
2841  0 long intVal = chLocal - '0';
2842  0 for (; ; ) {
2843  0 chLocal = charAt(bp + (offset++));
2844  0 if (chLocal >= '0' && chLocal <= '9') {
2845  0 intVal = intVal * 10 + (chLocal - '0');
2846  0 continue;
2847    } else {
2848  0 break;
2849    }
2850    }
2851   
2852  0 long power = 1;
2853  0 boolean small = (chLocal == '.');
2854  0 if (small) {
2855  0 chLocal = charAt(bp + (offset++));
2856  0 if (chLocal >= '0' && chLocal <= '9') {
2857  0 intVal = intVal * 10 + (chLocal - '0');
2858  0 power = 10;
2859  0 for (; ; ) {
2860  0 chLocal = charAt(bp + (offset++));
2861  0 if (chLocal >= '0' && chLocal <= '9') {
2862  0 intVal = intVal * 10 + (chLocal - '0');
2863  0 power *= 10;
2864  0 continue;
2865    } else {
2866  0 break;
2867    }
2868    }
2869    } else {
2870  0 matchStat = NOT_MATCH;
2871  0 return 0;
2872    }
2873    }
2874   
2875  0 boolean exp = chLocal == 'e' || chLocal == 'E';
2876  0 if (exp) {
2877  0 chLocal = charAt(bp + (offset++));
2878  0 if (chLocal == '+' || chLocal == '-') {
2879  0 chLocal = charAt(bp + (offset++));
2880    }
2881  0 for (; ; ) {
2882  0 if (chLocal >= '0' && chLocal <= '9') {
2883  0 chLocal = charAt(bp + (offset++));
2884    } else {
2885  0 break;
2886    }
2887    }
2888    }
2889   
2890  0 int start, count;
2891  0 if (quote) {
2892  0 if (chLocal != '"') {
2893  0 matchStat = NOT_MATCH;
2894  0 return 0;
2895    } else {
2896  0 chLocal = charAt(bp + (offset++));
2897    }
2898  0 start = bp + 1;
2899  0 count = bp + offset - start - 2;
2900    } else {
2901  0 start = bp;
2902  0 count = bp + offset - start - 1;
2903    }
2904   
2905  0 if (!exp && count < 17) {
2906  0 value = ((double) intVal) / power;
2907  0 if (negative) {
2908  0 value = -value;
2909    }
2910    } else {
2911  0 String text = this.subString(start, count);
2912  0 value = Double.parseDouble(text);
2913    }
2914  2 } else if (chLocal == 'n' && charAt(bp + offset) == 'u' && charAt(bp + offset + 1) == 'l' && charAt(bp + offset + 2) == 'l') {
2915  2 matchStat = VALUE_NULL;
2916  2 value = 0;
2917  2 offset += 3;
2918  2 chLocal = charAt(bp + offset++);
2919   
2920  2 if (quote && chLocal == '"') {
2921  2 chLocal = charAt(bp + offset++);
2922    }
2923   
2924  2 for (;;) {
2925  3 if (chLocal == ',') {
2926  1 bp += offset;
2927  1 this.ch = charAt(bp);
2928  1 matchStat = VALUE_NULL;
2929  1 token = JSONToken.COMMA;
2930  1 return value;
2931  2 } else if (chLocal == ']') {
2932  1 bp += offset;
2933  1 this.ch = charAt(bp);
2934  1 matchStat = VALUE_NULL;
2935  1 token = JSONToken.RBRACKET;
2936  1 return value;
2937  1 } else if (isWhitespace(chLocal)) {
2938  1 chLocal = charAt(bp + offset++);
2939  1 continue;
2940    }
2941  0 break;
2942    }
2943  0 matchStat = NOT_MATCH;
2944  0 return 0;
2945    } else {
2946  0 matchStat = NOT_MATCH;
2947  0 return 0;
2948    }
2949   
2950  0 if (chLocal == seperator) {
2951  0 bp += offset;
2952  0 this.ch = this.charAt(bp);
2953  0 matchStat = VALUE;
2954  0 token = JSONToken.COMMA;
2955  0 return value;
2956    } else {
2957  0 matchStat = NOT_MATCH;
2958  0 return value;
2959    }
2960    }
2961   
 
2962  0 toggle public BigDecimal scanDecimal(char seperator) {
2963  0 matchStat = UNKNOWN;
2964   
2965  0 int offset = 0;
2966  0 char chLocal = charAt(bp + (offset++));
2967  0 final boolean quote = chLocal == '"';
2968  0 if (quote) {
2969  0 chLocal = charAt(bp + (offset++));
2970    }
2971   
2972  0 boolean negative = chLocal == '-';
2973  0 if (negative) {
2974  0 chLocal = charAt(bp + (offset++));
2975    }
2976   
2977  0 BigDecimal value;
2978  0 if (chLocal >= '0' && chLocal <= '9') {
2979  0 for (;;) {
2980  0 chLocal = charAt(bp + (offset++));
2981  0 if (chLocal >= '0' && chLocal <= '9') {
2982  0 continue;
2983    } else {
2984  0 break;
2985    }
2986    }
2987   
2988  0 boolean small = (chLocal == '.');
2989  0 if (small) {
2990  0 chLocal = charAt(bp + (offset++));
2991  0 if (chLocal >= '0' && chLocal <= '9') {
2992  0 for (;;) {
2993  0 chLocal = charAt(bp + (offset++));
2994  0 if (chLocal >= '0' && chLocal <= '9') {
2995  0 continue;
2996    } else {
2997  0 break;
2998    }
2999    }
3000    } else {
3001  0 matchStat = NOT_MATCH;
3002  0 return null;
3003    }
3004    }
3005   
3006  0 boolean exp = chLocal == 'e' || chLocal == 'E';
3007  0 if (exp) {
3008  0 chLocal = charAt(bp + (offset++));
3009  0 if (chLocal == '+' || chLocal == '-') {
3010  0 chLocal = charAt(bp + (offset++));
3011    }
3012  0 for (;;) {
3013  0 if (chLocal >= '0' && chLocal <= '9') {
3014  0 chLocal = charAt(bp + (offset++));
3015    } else {
3016  0 break;
3017    }
3018    }
3019    }
3020   
3021  0 int start, count;
3022  0 if (quote) {
3023  0 if (chLocal != '"') {
3024  0 matchStat = NOT_MATCH;
3025  0 return null;
3026    } else {
3027  0 chLocal = charAt(bp + (offset++));
3028    }
3029  0 start = bp + 1;
3030  0 count = bp + offset - start - 2;
3031    } else {
3032  0 start = bp;
3033  0 count = bp + offset - start - 1;
3034    }
3035   
3036  0 char[] chars = this.sub_chars(start, count);
3037  0 value = new BigDecimal(chars);
3038  0 } else if (chLocal == 'n' && charAt(bp + offset) == 'u' && charAt(bp + offset + 1) == 'l' && charAt(bp + offset + 2) == 'l') {
3039  0 matchStat = VALUE_NULL;
3040  0 value = null;
3041  0 offset += 3;
3042  0 chLocal = charAt(bp + offset++);
3043   
3044  0 if (quote && chLocal == '"') {
3045  0 chLocal = charAt(bp + offset++);
3046    }
3047   
3048  0 for (;;) {
3049  0 if (chLocal == ',') {
3050  0 bp += offset;
3051  0 this.ch = charAt(bp);
3052  0 matchStat = VALUE_NULL;
3053  0 token = JSONToken.COMMA;
3054  0 return value;
3055  0 } else if (chLocal == '}') {
3056  0 bp += offset;
3057  0 this.ch = charAt(bp);
3058  0 matchStat = VALUE_NULL;
3059  0 token = JSONToken.RBRACE;
3060  0 return value;
3061  0 } else if (isWhitespace(chLocal)) {
3062  0 chLocal = charAt(bp + offset++);
3063  0 continue;
3064    }
3065  0 break;
3066    }
3067  0 matchStat = NOT_MATCH;
3068  0 return null;
3069    } else {
3070  0 matchStat = NOT_MATCH;
3071  0 return null;
3072    }
3073   
3074  0 if (chLocal == ',') {
3075  0 bp += offset;
3076  0 this.ch = this.charAt(bp);
3077  0 matchStat = VALUE;
3078  0 token = JSONToken.COMMA;
3079  0 return value;
3080    }
3081   
3082  0 if (chLocal == ']') {
3083  0 chLocal = charAt(bp + (offset++));
3084  0 if (chLocal == ',') {
3085  0 token = JSONToken.COMMA;
3086  0 bp += offset;
3087  0 this.ch = this.charAt(bp);
3088  0 } else if (chLocal == ']') {
3089  0 token = JSONToken.RBRACKET;
3090  0 bp += offset;
3091  0 this.ch = this.charAt(bp);
3092  0 } else if (chLocal == '}') {
3093  0 token = JSONToken.RBRACE;
3094  0 bp += offset;
3095  0 this.ch = this.charAt(bp);
3096  0 } else if (chLocal == EOI) {
3097  0 token = JSONToken.EOF;
3098  0 bp += (offset - 1);
3099  0 ch = EOI;
3100    } else {
3101  0 matchStat = NOT_MATCH;
3102  0 return null;
3103    }
3104  0 matchStat = END;
3105    } else {
3106  0 matchStat = NOT_MATCH;
3107  0 return null;
3108    }
3109   
3110  0 return value;
3111    }
3112   
 
3113  1000005 toggle public final float[] scanFieldFloatArray(char[] fieldName) {
3114  1000005 matchStat = UNKNOWN;
3115   
3116  1000005 if (!charArrayCompare(fieldName)) {
3117  0 matchStat = NOT_MATCH_NAME;
3118  0 return null;
3119    }
3120   
3121  1000005 int offset = fieldName.length;
3122  1000005 char chLocal = charAt(bp + (offset++));
3123  1000005 if (chLocal != '[') {
3124  2 matchStat = NOT_MATCH_NAME;
3125  2 return null;
3126    }
3127  1000003 chLocal = charAt(bp + (offset++));
3128   
3129  1000003 float[] array = new float[16];
3130  1000003 int arrayIndex = 0;
3131   
3132  1000003 for (;;) {
3133  1000008 int start = bp + offset - 1;
3134   
3135  1000008 boolean negative = chLocal == '-';
3136  1000008 if (negative) {
3137  2 chLocal = charAt(bp + (offset++));
3138    }
3139   
3140  1000008 if (chLocal >= '0' && chLocal <= '9') {
3141  1000007 int intVal = chLocal - '0';
3142  1000007 for (; ; ) {
3143  1000007 chLocal = charAt(bp + (offset++));
3144  1000007 if (chLocal >= '0' && chLocal <= '9') {
3145  0 intVal = intVal * 10 + (chLocal - '0');
3146  0 continue;
3147    } else {
3148  1000007 break;
3149    }
3150    }
3151   
3152  1000007 int power = 1;
3153  1000007 boolean small = (chLocal == '.');
3154  1000007 if (small) {
3155  1000004 chLocal = charAt(bp + (offset++));
3156  1000004 power = 10;
3157  1000004 if (chLocal >= '0' && chLocal <= '9') {
3158  1000004 intVal = intVal * 10 + (chLocal - '0');
3159  1000004 for (; ; ) {
3160  7624674 chLocal = charAt(bp + (offset++));
3161   
3162  7624674 if (chLocal >= '0' && chLocal <= '9') {
3163  6624670 intVal = intVal * 10 + (chLocal - '0');
3164  6624670 power *= 10;
3165  6624670 continue;
3166    } else {
3167  1000004 break;
3168    }
3169    }
3170    } else {
3171  0 matchStat = NOT_MATCH;
3172  0 return null;
3173    }
3174    }
3175   
3176  1000007 boolean exp = chLocal == 'e' || chLocal == 'E';
3177  1000007 if (exp) {
3178  1044 chLocal = charAt(bp + (offset++));
3179  1044 if (chLocal == '+' || chLocal == '-') {
3180  1044 chLocal = charAt(bp + (offset++));
3181    }
3182  1044 for (;;) {
3183  2088 if (chLocal >= '0' && chLocal <= '9') {
3184  1044 chLocal = charAt(bp + (offset++));
3185    } else {
3186  1044 break;
3187    }
3188    }
3189    }
3190   
3191  1000007 int count = bp + offset - start - 1;
3192   
3193  1000007 float value;
3194  1000007 if (!exp && count < 10) {
3195  396552 value = ((float) intVal) / power;
3196  396552 if (negative) {
3197  2 value = -value;
3198    }
3199    } else {
3200  603455 String text = this.subString(start, count);
3201  603455 value = Float.parseFloat(text);
3202    }
3203   
3204  1000007 if (arrayIndex >= array.length) {
3205  0 float[] tmp = new float[array.length * 3 / 2];
3206  0 System.arraycopy(array, 0, tmp, 0, arrayIndex);
3207  0 array = tmp;
3208    }
3209  1000007 array[arrayIndex++] = value;
3210   
3211  1000007 if (chLocal == ',') {
3212  5 chLocal = charAt(bp + (offset++));
3213  1000002 } else if (chLocal == ']') {
3214  1000002 chLocal = charAt(bp + (offset++));
3215  1000002 break;
3216    }
3217    } else {
3218  1 matchStat = NOT_MATCH;
3219  1 return null;
3220    }
3221    }
3222   
3223   
3224  1000002 if (arrayIndex != array.length) {
3225  1000002 float[] tmp = new float[arrayIndex];
3226  1000002 System.arraycopy(array, 0, tmp, 0, arrayIndex);
3227  1000002 array = tmp;
3228    }
3229   
3230  1000002 if (chLocal == ',') {
3231  0 bp += (offset - 1);
3232  0 this.next();
3233  0 matchStat = VALUE;
3234  0 token = JSONToken.COMMA;
3235  0 return array;
3236    }
3237   
3238  1000002 if (chLocal == '}') {
3239  1000002 chLocal = charAt(bp + (offset++));
3240  1000002 if (chLocal == ',') {
3241  0 token = JSONToken.COMMA;
3242  0 bp += (offset - 1);
3243  0 this.next();
3244  1000002 } else if (chLocal == ']') {
3245  0 token = JSONToken.RBRACKET;
3246  0 bp += (offset - 1);
3247  0 this.next();
3248  1000002 } else if (chLocal == '}') {
3249  0 token = JSONToken.RBRACE;
3250  0 bp += (offset - 1);
3251  0 this.next();
3252  1000002 } else if (chLocal == EOI) {
3253  1000002 bp += (offset - 1);
3254  1000002 token = JSONToken.EOF;
3255  1000002 ch = EOI;
3256    } else {
3257  0 matchStat = NOT_MATCH;
3258  0 return null;
3259    }
3260  1000002 matchStat = END;
3261    } else {
3262  0 matchStat = NOT_MATCH;
3263  0 return null;
3264    }
3265   
3266  1000002 return array;
3267    }
3268   
 
3269  4 toggle public final float[][] scanFieldFloatArray2(char[] fieldName) {
3270  4 matchStat = UNKNOWN;
3271   
3272  4 if (!charArrayCompare(fieldName)) {
3273  0 matchStat = NOT_MATCH_NAME;
3274  0 return null;
3275    }
3276   
3277  4 int offset = fieldName.length;
3278  4 char chLocal = charAt(bp + (offset++));
3279   
3280  4 if (chLocal != '[') {
3281  0 matchStat = NOT_MATCH_NAME;
3282  0 return null;
3283    }
3284  4 chLocal = charAt(bp + (offset++));
3285   
3286  4 float[][] arrayarray = new float[16][];
3287  4 int arrayarrayIndex = 0;
3288   
3289  4 for (;;) {
3290  4 if (chLocal == '[') {
3291  2 chLocal = charAt(bp + (offset++));
3292   
3293  2 float[] array = new float[16];
3294  2 int arrayIndex = 0;
3295   
3296  2 for (; ; ) {
3297  6 int start = bp + offset - 1;
3298  6 boolean negative = chLocal == '-';
3299  6 if (negative) {
3300  2 chLocal = charAt(bp + (offset++));
3301    }
3302   
3303  6 if (chLocal >= '0' && chLocal <= '9') {
3304  6 int intVal = chLocal - '0';
3305  6 for (; ; ) {
3306  6 chLocal = charAt(bp + (offset++));
3307   
3308  6 if (chLocal >= '0' && chLocal <= '9') {
3309  0 intVal = intVal * 10 + (chLocal - '0');
3310  0 continue;
3311    } else {
3312  6 break;
3313    }
3314    }
3315   
3316  6 int power = 1;
3317  6 if (chLocal == '.') {
3318  4 chLocal = charAt(bp + (offset++));
3319   
3320  4 if (chLocal >= '0' && chLocal <= '9') {
3321  4 intVal = intVal * 10 + (chLocal - '0');
3322  4 power = 10;
3323  4 for (; ; ) {
3324  4 chLocal = charAt(bp + (offset++));
3325   
3326  4 if (chLocal >= '0' && chLocal <= '9') {
3327  0 intVal = intVal * 10 + (chLocal - '0');
3328  0 power *= 10;
3329  0 continue;
3330    } else {
3331  4 break;
3332    }
3333    }
3334    } else {
3335  0 matchStat = NOT_MATCH;
3336  0 return null;
3337    }
3338    }
3339   
3340  6 boolean exp = chLocal == 'e' || chLocal == 'E';
3341  6 if (exp) {
3342  0 chLocal = charAt(bp + (offset++));
3343  0 if (chLocal == '+' || chLocal == '-') {
3344  0 chLocal = charAt(bp + (offset++));
3345    }
3346  0 for (;;) {
3347  0 if (chLocal >= '0' && chLocal <= '9') {
3348  0 chLocal = charAt(bp + (offset++));
3349    } else {
3350  0 break;
3351    }
3352    }
3353    }
3354   
3355  6 int count = bp + offset - start - 1;
3356  6 float value;
3357  6 if (!exp && count < 10) {
3358  6 value = ((float) intVal) / power;
3359  6 if (negative) {
3360  2 value = -value;
3361    }
3362    } else {
3363  0 String text = this.subString(start, count);
3364  0 value = Float.parseFloat(text);
3365    }
3366   
3367  6 if (arrayIndex >= array.length) {
3368  0 float[] tmp = new float[array.length * 3 / 2];
3369  0 System.arraycopy(array, 0, tmp, 0, arrayIndex);
3370  0 array = tmp;
3371    }
3372  6 array[arrayIndex++] = value;
3373   
3374  6 if (chLocal == ',') {
3375  4 chLocal = charAt(bp + (offset++));
3376  2 } else if (chLocal == ']') {
3377  2 chLocal = charAt(bp + (offset++));
3378  2 break;
3379    }
3380    } else {
3381  0 matchStat = NOT_MATCH;
3382  0 return null;
3383    }
3384    }
3385   
3386    // compact
3387  2 if (arrayIndex != array.length) {
3388  2 float[] tmp = new float[arrayIndex];
3389  2 System.arraycopy(array, 0, tmp, 0, arrayIndex);
3390  2 array = tmp;
3391    }
3392   
3393  2 if (arrayarrayIndex >= arrayarray.length) {
3394  0 float[][] tmp = new float[arrayarray.length * 3 / 2][];
3395  0 System.arraycopy(array, 0, tmp, 0, arrayIndex);
3396  0 arrayarray = tmp;
3397    }
3398  2 arrayarray[arrayarrayIndex++] = array;
3399   
3400  2 if (chLocal == ',') {
3401  0 chLocal = charAt(bp + (offset++));
3402  2 } else if (chLocal == ']') {
3403  2 chLocal = charAt(bp + (offset++));
3404  2 break;
3405    }
3406    } else {
3407  2 break;
3408    }
3409    }
3410   
3411    // compact
3412  4 if (arrayarrayIndex != arrayarray.length) {
3413  4 float[][] tmp = new float[arrayarrayIndex][];
3414  4 System.arraycopy(arrayarray, 0, tmp, 0, arrayarrayIndex);
3415  4 arrayarray = tmp;
3416    }
3417   
3418  4 if (chLocal == ',') {
3419  0 bp += (offset - 1);
3420  0 this.next();
3421  0 matchStat = VALUE;
3422  0 token = JSONToken.COMMA;
3423  0 return arrayarray;
3424    }
3425   
3426  4 if (chLocal == '}') {
3427  2 chLocal = charAt(bp + (offset++));
3428  2 if (chLocal == ',') {
3429  0 token = JSONToken.COMMA;
3430  0 bp += (offset - 1);
3431  0 this.next();
3432  2 } else if (chLocal == ']') {
3433  0 token = JSONToken.RBRACKET;
3434  0 bp += (offset - 1);
3435  0 this.next();
3436  2 } else if (chLocal == '}') {
3437  0 token = JSONToken.RBRACE;
3438  0 bp += (offset - 1);
3439  0 this.next();
3440  2 } else if (chLocal == EOI) {
3441  2 bp += (offset - 1);
3442  2 token = JSONToken.EOF;
3443  2 ch = EOI;
3444    } else {
3445  0 matchStat = NOT_MATCH;
3446  0 return null;
3447    }
3448  2 matchStat = END;
3449    } else {
3450  2 matchStat = NOT_MATCH;
3451  2 return null;
3452    }
3453   
3454  2 return arrayarray;
3455    }
3456   
 
3457  1002232 toggle public final double scanFieldDouble(char[] fieldName) {
3458  1002232 matchStat = UNKNOWN;
3459   
3460  1002232 if (!charArrayCompare(fieldName)) {
3461  83 matchStat = NOT_MATCH_NAME;
3462  83 return 0;
3463    }
3464   
3465  1002149 int offset = fieldName.length;
3466  1002149 char chLocal = charAt(bp + (offset++));
3467  1002149 final boolean quote = chLocal == '"';
3468  1002149 if (quote) {
3469  21 chLocal = charAt(bp + (offset++));
3470    }
3471   
3472  1002149 boolean negative = chLocal == '-';
3473  1002149 if (negative) {
3474  6 chLocal = charAt(bp + (offset++));
3475    }
3476   
3477  1002149 double value;
3478  1002149 if (chLocal >= '0' && chLocal <= '9') {
3479  1002123 long intVal = chLocal - '0';
3480   
3481  1002123 for (;;) {
3482  1006121 chLocal = charAt(bp + (offset++));
3483  1006121 if (chLocal >= '0' && chLocal <= '9') {
3484  3998 intVal = intVal * 10 + (chLocal - '0');
3485  3998 continue;
3486    } else {
3487  1002123 break;
3488    }
3489    }
3490   
3491  1002123 long power = 1;
3492  1002123 boolean small = (chLocal == '.');
3493  1002123 if (small) {
3494  1002104 chLocal = charAt(bp + (offset++));
3495  1002104 if (chLocal >= '0' && chLocal <= '9') {
3496  1002100 intVal = intVal * 10 + (chLocal - '0');
3497  1002100 power = 10;
3498  1002100 for (;;) {
3499  16268249 chLocal = charAt(bp + (offset++));
3500  16268249 if (chLocal >= '0' && chLocal <= '9') {
3501  15266149 intVal = intVal * 10 + (chLocal - '0');
3502  15266149 power *= 10;
3503  15266149 continue;
3504    } else {
3505  1002100 break;
3506    }
3507    }
3508    } else {
3509  4 matchStat = NOT_MATCH;
3510  4 return 0;
3511    }
3512    }
3513   
3514  1002119 boolean exp = chLocal == 'e' || chLocal == 'E';
3515  1002119 if (exp) {
3516  1042 chLocal = charAt(bp + (offset++));
3517  1042 if (chLocal == '+' || chLocal == '-') {
3518  1039 chLocal = charAt(bp + (offset++));
3519    }
3520  1042 for (;;) {
3521  2088 if (chLocal >= '0' && chLocal <= '9') {
3522  1046 chLocal = charAt(bp + (offset++));
3523    } else {
3524  1042 break;
3525    }
3526    }
3527    }
3528   
3529  1002119 int start, count;
3530  1002119 if (quote) {
3531  12 if (chLocal != '"') {
3532  0 matchStat = NOT_MATCH;
3533  0 return 0;
3534    } else {
3535  12 chLocal = charAt(bp + (offset++));
3536    }
3537  12 start = bp + fieldName.length + 1;
3538  12 count = bp + offset - start - 2;
3539    } else {
3540  1002107 start = bp + fieldName.length;
3541  1002107 count = bp + offset - start - 1;
3542    }
3543   
3544  1002119 if (!exp && count < 17) {
3545  9704 value = ((double) intVal) / power;
3546  9704 if (negative) {
3547  6 value = -value;
3548    }
3549    } else {
3550  992415 String text = this.subString(start, count);
3551  992415 value = Double.parseDouble(text);
3552    }
3553  26 } else if (chLocal == 'n' &&
3554    charAt(bp + offset) == 'u' &&
3555    charAt(bp + offset + 1) == 'l' &&
3556    charAt(bp + offset + 2) == 'l') {
3557  19 matchStat = VALUE_NULL;
3558  19 value = 0;
3559  19 offset += 3;
3560  19 chLocal = charAt(bp + offset++);
3561   
3562  19 if (quote && chLocal == '"') {
3563  7 chLocal = charAt(bp + offset++);
3564    }
3565   
3566  19 for (;;) {
3567  26 if (chLocal == ',') {
3568  9 bp += offset;
3569  9 this.ch = charAt(bp);
3570  9 matchStat = VALUE_NULL;
3571  9 token = JSONToken.COMMA;
3572  9 return value;
3573  17 } else if (chLocal == '}') {
3574  10 bp += offset;
3575  10 this.ch = charAt(bp);
3576  10 matchStat = VALUE_NULL;
3577  10 token = JSONToken.RBRACE;
3578  10 return value;
3579  7 } else if (isWhitespace(chLocal)) {
3580  7 chLocal = charAt(bp + offset++);
3581  7 continue;
3582    }
3583  0 break;
3584    }
3585  0 matchStat = NOT_MATCH;
3586  0 return 0;
3587    } else {
3588  7 matchStat = NOT_MATCH;
3589  7 return 0;
3590    }
3591   
3592  1002119 if (chLocal == ',') {
3593  34 bp += offset;
3594  34 this.ch = this.charAt(bp);
3595  34 matchStat = VALUE;
3596  34 token = JSONToken.COMMA;
3597  34 return value;
3598    }
3599   
3600  1002085 if (chLocal == '}') {
3601  1002076 chLocal = charAt(bp + (offset++));
3602  1002076 if (chLocal == ',') {
3603  2049 token = JSONToken.COMMA;
3604  2049 bp += offset;
3605  2049 this.ch = this.charAt(bp);
3606  1000027 } else if (chLocal == ']') {
3607  4 token = JSONToken.RBRACKET;
3608  4 bp += offset;
3609  4 this.ch = this.charAt(bp);
3610  1000023 } else if (chLocal == '}') {
3611  7 token = JSONToken.RBRACE;
3612  7 bp += offset;
3613  7 this.ch = this.charAt(bp);
3614  1000015 } else if (chLocal == EOI) {
3615  1000015 token = JSONToken.EOF;
3616  1000015 bp += (offset - 1);
3617  1000015 ch = EOI;
3618    } else {
3619  0 matchStat = NOT_MATCH;
3620  0 return 0;
3621    }
3622  1002075 matchStat = END;
3623    } else {
3624  9 matchStat = NOT_MATCH;
3625  9 return 0;
3626    }
3627   
3628  1002075 return value;
3629    }
3630   
 
3631  32 toggle public BigDecimal scanFieldDecimal(char[] fieldName) {
3632  32 matchStat = UNKNOWN;
3633   
3634  32 if (!charArrayCompare(fieldName)) {
3635  19 matchStat = NOT_MATCH_NAME;
3636  19 return null;
3637    }
3638   
3639  13 int offset = fieldName.length;
3640  13 char chLocal = charAt(bp + (offset++));
3641  13 final boolean quote = chLocal == '"';
3642  13 if (quote) {
3643  1 chLocal = charAt(bp + (offset++));
3644    }
3645   
3646  13 boolean negative = chLocal == '-';
3647  13 if (negative) {
3648  0 chLocal = charAt(bp + (offset++));
3649    }
3650   
3651  13 BigDecimal value;
3652  13 if (chLocal >= '0' && chLocal <= '9') {
3653  9 for (;;) {
3654  84 chLocal = charAt(bp + (offset++));
3655  84 if (chLocal >= '0' && chLocal <= '9') {
3656  75 continue;
3657    } else {
3658  9 break;
3659    }
3660    }
3661   
3662  9 boolean small = (chLocal == '.');
3663  9 if (small) {
3664  8 chLocal = charAt(bp + (offset++));
3665  8 if (chLocal >= '0' && chLocal <= '9') {
3666  8 for (;;) {
3667  36 chLocal = charAt(bp + (offset++));
3668  36 if (chLocal >= '0' && chLocal <= '9') {
3669  28 continue;
3670    } else {
3671  8 break;
3672    }
3673    }
3674    } else {
3675  0 matchStat = NOT_MATCH;
3676  0 return null;
3677    }
3678    }
3679   
3680  9 boolean exp = chLocal == 'e' || chLocal == 'E';
3681  9 if (exp) {
3682  0 chLocal = charAt(bp + (offset++));
3683  0 if (chLocal == '+' || chLocal == '-') {
3684  0 chLocal = charAt(bp + (offset++));
3685    }
3686  0 for (;;) {
3687  0 if (chLocal >= '0' && chLocal <= '9') {
3688  0 chLocal = charAt(bp + (offset++));
3689    } else {
3690  0 break;
3691    }
3692    }
3693    }
3694   
3695  9 int start, count;
3696  9 if (quote) {
3697  0 if (chLocal != '"') {
3698  0 matchStat = NOT_MATCH;
3699  0 return null;
3700    } else {
3701  0 chLocal = charAt(bp + (offset++));
3702    }
3703  0 start = bp + fieldName.length + 1;
3704  0 count = bp + offset - start - 2;
3705    } else {
3706  9 start = bp + fieldName.length;
3707  9 count = bp + offset - start - 1;
3708    }
3709   
3710  9 char[] chars = this.sub_chars(start, count);
3711  9 value = new BigDecimal(chars);
3712  4 } else if (chLocal == 'n' &&
3713    charAt(bp + offset) == 'u' &&
3714    charAt(bp + offset + 1) == 'l' &&
3715    charAt(bp + offset + 2) == 'l') {
3716  1 matchStat = VALUE_NULL;
3717  1 value = null;
3718  1 offset += 3;
3719  1 chLocal = charAt(bp + offset++);
3720   
3721  1 if (quote && chLocal == '"') {
3722  0 chLocal = charAt(bp + offset++);
3723    }
3724   
3725  1 for (;;) {
3726  1 if (chLocal == ',') {
3727  0 bp += offset;
3728  0 this.ch = charAt(bp);
3729  0 matchStat = VALUE_NULL;
3730  0 token = JSONToken.COMMA;
3731  0 return value;
3732  1 } else if (chLocal == '}') {
3733  1 bp += offset;
3734  1 this.ch = charAt(bp);
3735  1 matchStat = VALUE_NULL;
3736  1 token = JSONToken.RBRACE;
3737  1 return value;
3738  0 } else if (isWhitespace(chLocal)) {
3739  0 chLocal = charAt(bp + offset++);
3740  0 continue;
3741    }
3742  0 break;
3743    }
3744  0 matchStat = NOT_MATCH;
3745  0 return null;
3746    } else {
3747  3 matchStat = NOT_MATCH;
3748  3 return null;
3749    }
3750   
3751  9 if (chLocal == ',') {
3752  6 bp += offset;
3753  6 this.ch = this.charAt(bp);
3754  6 matchStat = VALUE;
3755  6 token = JSONToken.COMMA;
3756  6 return value;
3757    }
3758   
3759  3 if (chLocal == '}') {
3760  3 chLocal = charAt(bp + (offset++));
3761  3 if (chLocal == ',') {
3762  0 token = JSONToken.COMMA;
3763  0 bp += offset;
3764  0 this.ch = this.charAt(bp);
3765  3 } else if (chLocal == ']') {
3766  2 token = JSONToken.RBRACKET;
3767  2 bp += offset;
3768  2 this.ch = this.charAt(bp);
3769  1 } else if (chLocal == '}') {
3770  0 token = JSONToken.RBRACE;
3771  0 bp += offset;
3772  0 this.ch = this.charAt(bp);
3773  1 } else if (chLocal == EOI) {
3774  1 token = JSONToken.EOF;
3775  1 bp += (offset - 1);
3776  1 ch = EOI;
3777    } else {
3778  0 matchStat = NOT_MATCH;
3779  0 return null;
3780    }
3781  3 matchStat = END;
3782    } else {
3783  0 matchStat = NOT_MATCH;
3784  0 return null;
3785    }
3786   
3787  3 return value;
3788    }
3789   
 
3790  11 toggle public BigInteger scanFieldBigInteger(char[] fieldName) {
3791  11 matchStat = UNKNOWN;
3792   
3793  11 if (!charArrayCompare(fieldName)) {
3794  3 matchStat = NOT_MATCH_NAME;
3795  3 return null;
3796    }
3797   
3798  8 int offset = fieldName.length;
3799  8 char chLocal = charAt(bp + (offset++));
3800  8 final boolean quote = chLocal == '"';
3801  8 if (quote) {
3802  0 chLocal = charAt(bp + (offset++));
3803    }
3804   
3805  8 boolean negative = chLocal == '-';
3806  8 if (negative) {
3807  0 chLocal = charAt(bp + (offset++));
3808    }
3809   
3810  8 BigInteger value;
3811  8 if (chLocal >= '0' && chLocal <= '9') {
3812  6 long intVal = chLocal - '0';
3813  6 boolean overflow = false;
3814  6 long temp;
3815  6 for (;;) {
3816  64 chLocal = charAt(bp + (offset++));
3817  64 if (chLocal >= '0' && chLocal <= '9') {
3818  61 temp = intVal * 10 + (chLocal - '0');
3819  61 if (temp < intVal) {
3820  3 overflow = true;
3821  3 break;
3822    }
3823  58 intVal = temp;
3824  58 continue;
3825    } else {
3826  3 break;
3827    }
3828    }
3829   
3830  6 int start, count;
3831  6 if (quote) {
3832  0 if (chLocal != '"') {
3833  0 matchStat = NOT_MATCH;
3834  0 return null;
3835    } else {
3836  0 chLocal = charAt(bp + (offset++));
3837    }
3838  0 start = bp + fieldName.length + 1;
3839  0 count = bp + offset - start - 2;
3840    } else {
3841  6 start = bp + fieldName.length;
3842  6 count = bp + offset - start - 1;
3843    }
3844   
3845  6 if (!overflow && (count < 20 || (negative && count < 21))) {
3846  3 value = BigInteger.valueOf(negative ? -intVal : intVal);
3847    } else {
3848   
3849    // char[] chars = this.sub_chars(negative ? start + 1 : start, count);
3850    // value = new BigInteger(chars, )
3851  3 String strVal = this.subString(start, count);
3852  3 value = new BigInteger(strVal);
3853    }
3854  2 } else if (chLocal == 'n' &&
3855    charAt(bp + offset) == 'u' &&
3856    charAt(bp + offset + 1) == 'l' &&
3857    charAt(bp + offset + 2) == 'l') {
3858  2 matchStat = VALUE_NULL;
3859  2 value = null;
3860  2 offset += 3;
3861  2 chLocal = charAt(bp + offset++);
3862   
3863  2 if (quote && chLocal == '"') {
3864  0 chLocal = charAt(bp + offset++);
3865    }
3866   
3867  2 for (;;) {
3868  2 if (chLocal == ',') {
3869  0 bp += offset;
3870  0 this.ch = charAt(bp);
3871  0 matchStat = VALUE_NULL;
3872  0 token = JSONToken.COMMA;
3873  0 return value;
3874  2 } else if (chLocal == '}') {
3875  2 bp += offset;
3876  2 this.ch = charAt(bp);
3877  2 matchStat = VALUE_NULL;
3878  2 token = JSONToken.RBRACE;
3879  2 return value;
3880  0 } else if (isWhitespace(chLocal)) {
3881  0 chLocal = charAt(bp + offset++);
3882  0 continue;
3883    }
3884  0 break;
3885    }
3886  0 matchStat = NOT_MATCH;
3887  0 return null;
3888    } else {
3889  0 matchStat = NOT_MATCH;
3890  0 return null;
3891    }
3892   
3893  6 if (chLocal == ',') {
3894  0 bp += offset;
3895  0 this.ch = this.charAt(bp);
3896  0 matchStat = VALUE;
3897  0 token = JSONToken.COMMA;
3898  0 return value;
3899    }
3900   
3901  6 if (chLocal == '}') {
3902  2 chLocal = charAt(bp + (offset++));
3903  2 if (chLocal == ',') {
3904  0 token = JSONToken.COMMA;
3905  0 bp += offset;
3906  0 this.ch = this.charAt(bp);
3907  2 } else if (chLocal == ']') {
3908  0 token = JSONToken.RBRACKET;
3909  0 bp += offset;
3910  0 this.ch = this.charAt(bp);
3911  2 } else if (chLocal == '}') {
3912  0 token = JSONToken.RBRACE;
3913  0 bp += offset;
3914  0 this.ch = this.charAt(bp);
3915  2 } else if (chLocal == EOI) {
3916  2 token = JSONToken.EOF;
3917  2 bp += (offset - 1);
3918  2 ch = EOI;
3919    } else {
3920  0 matchStat = NOT_MATCH;
3921  0 return null;
3922    }
3923  2 matchStat = END;
3924    } else {
3925  4 matchStat = NOT_MATCH;
3926  4 return null;
3927    }
3928   
3929  2 return value;
3930    }
3931   
 
3932  6 toggle public java.util.Date scanFieldDate(char[] fieldName) {
3933  6 matchStat = UNKNOWN;
3934   
3935  6 if (!charArrayCompare(fieldName)) {
3936  0 matchStat = NOT_MATCH_NAME;
3937  0 return null;
3938    }
3939   
3940    // int index = bp + fieldName.length;
3941   
3942  6 int offset = fieldName.length;
3943  6 char chLocal = charAt(bp + (offset++));
3944   
3945  6 final java.util.Date dateVal;
3946  6 if (chLocal == '"'){
3947  4 int startIndex = bp + fieldName.length + 1;
3948  4 int endIndex = indexOf('"', startIndex);
3949  4 if (endIndex == -1) {
3950  0 throw new JSONException("unclosed str");
3951    }
3952   
3953  4 int startIndex2 = bp + fieldName.length + 1; // must re compute
3954  4 String stringVal = subString(startIndex2, endIndex - startIndex2);
3955  4 if (stringVal.indexOf('\\') != -1) {
3956  0 for (;;) {
3957  0 int slashCount = 0;
3958  0 for (int i = endIndex - 1; i >= 0; --i) {
3959  0 if (charAt(i) == '\\') {
3960  0 slashCount++;
3961    } else {
3962  0 break;
3963    }
3964    }
3965  0 if (slashCount % 2 == 0) {
3966  0 break;
3967    }
3968  0 endIndex = indexOf('"', endIndex + 1);
3969    }
3970   
3971  0 int chars_len = endIndex - (bp + fieldName.length + 1);
3972  0 char[] chars = sub_chars( bp + fieldName.length + 1, chars_len);
3973   
3974  0 stringVal = readString(chars, chars_len);
3975    }
3976   
3977  4 offset += (endIndex - (bp + fieldName.length + 1) + 1);
3978  4 chLocal = charAt(bp + (offset++));
3979   
3980  4 JSONScanner dateLexer = new JSONScanner(stringVal);
3981  4 try {
3982  4 if (dateLexer.scanISO8601DateIfMatch(false)) {
3983  3 Calendar calendar = dateLexer.getCalendar();
3984  3 dateVal = calendar.getTime();
3985    } else {
3986  1 matchStat = NOT_MATCH;
3987  1 return null;
3988    }
3989    } finally {
3990  4 dateLexer.close();
3991    }
3992  2 } else if (chLocal == '-' || (chLocal >= '0' && chLocal <= '9')) {
3993  2 long millis = 0;
3994   
3995  2 boolean negative = false;
3996  2 if (chLocal == '-') {
3997  0 chLocal = charAt(bp + (offset++));
3998  0 negative = true;
3999    }
4000   
4001  2 if (chLocal >= '0' && chLocal <= '9') {
4002  2 millis = chLocal - '0';
4003  2 for (; ; ) {
4004  26 chLocal = charAt(bp + (offset++));
4005  26 if (chLocal >= '0' && chLocal <= '9') {
4006  24 millis = millis * 10 + (chLocal - '0');
4007    } else {
4008  2 break;
4009    }
4010    }
4011    }
4012   
4013  2 if (millis < 0) {
4014  0 matchStat = NOT_MATCH;
4015  0 return null;
4016    }
4017   
4018  2 if (negative) {
4019  0 millis = -millis;
4020    }
4021   
4022  2 dateVal = new java.util.Date(millis);
4023    } else {
4024  0 matchStat = NOT_MATCH;
4025  0 return null;
4026    }
4027   
4028  5 if (chLocal == ',') {
4029  2 bp += offset;
4030  2 this.ch = this.charAt(bp);
4031  2 matchStat = VALUE;
4032  2 return dateVal;
4033    }
4034   
4035  3 if (chLocal == '}') {
4036  3 chLocal = charAt(bp + (offset++));
4037  3 if (chLocal == ',') {
4038  0 token = JSONToken.COMMA;
4039  0 bp += offset;
4040  0 this.ch = this.charAt(bp);
4041  3 } else if (chLocal == ']') {
4042  0 token = JSONToken.RBRACKET;
4043  0 bp += offset;
4044  0 this.ch = this.charAt(bp);
4045  3 } else if (chLocal == '}') {
4046  0 token = JSONToken.RBRACE;
4047  0 bp += offset;
4048  0 this.ch = this.charAt(bp);
4049  3 } else if (chLocal == EOI) {
4050  3 token = JSONToken.EOF;
4051  3 bp += (offset - 1);
4052  3 ch = EOI;
4053    } else {
4054  0 matchStat = NOT_MATCH;
4055  0 return null;
4056    }
4057  3 matchStat = END;
4058    } else {
4059  0 matchStat = NOT_MATCH;
4060  0 return null;
4061    }
4062   
4063  3 return dateVal;
4064    }
4065   
 
4066  6 toggle public java.util.Date scanDate(char seperator) {
4067  6 matchStat = UNKNOWN;
4068   
4069  6 int offset = 0;
4070  6 char chLocal = charAt(bp + (offset++));
4071   
4072  6 final java.util.Date dateVal;
4073  6 if (chLocal == '"'){
4074  2 int startIndex = bp + 1;
4075  2 int endIndex = indexOf('"', startIndex);
4076  2 if (endIndex == -1) {
4077  0 throw new JSONException("unclosed str");
4078    }
4079   
4080  2 int startIndex2 = bp + 1; // must re compute
4081  2 String stringVal = subString(startIndex2, endIndex - startIndex2);
4082  2 if (stringVal.indexOf('\\') != -1) {
4083  0 for (;;) {
4084  0 int slashCount = 0;
4085  0 for (int i = endIndex - 1; i >= 0; --i) {
4086  0 if (charAt(i) == '\\') {
4087  0 slashCount++;
4088    } else {
4089  0 break;
4090    }
4091    }
4092  0 if (slashCount % 2 == 0) {
4093  0 break;
4094    }
4095  0 endIndex = indexOf('"', endIndex + 1);
4096    }
4097   
4098  0 int chars_len = endIndex - (bp + 1);
4099  0 char[] chars = sub_chars( bp + 1, chars_len);
4100   
4101  0 stringVal = readString(chars, chars_len);
4102    }
4103   
4104  2 offset += (endIndex - (bp + 1) + 1);
4105  2 chLocal = charAt(bp + (offset++));
4106   
4107  2 JSONScanner dateLexer = new JSONScanner(stringVal);
4108  2 try {
4109  2 if (dateLexer.scanISO8601DateIfMatch(false)) {
4110  2 Calendar calendar = dateLexer.getCalendar();
4111  2 dateVal = calendar.getTime();
4112    } else {
4113  0 matchStat = NOT_MATCH;
4114  0 return null;
4115    }
4116    } finally {
4117  2 dateLexer.close();
4118    }
4119  4 } else if (chLocal == '-' || (chLocal >= '0' && chLocal <= '9')) {
4120  2 long millis = 0;
4121   
4122  2 boolean negative = false;
4123  2 if (chLocal == '-') {
4124  0 chLocal = charAt(bp + (offset++));
4125  0 negative = true;
4126    }
4127   
4128  2 if (chLocal >= '0' && chLocal <= '9') {
4129  2 millis = chLocal - '0';
4130  2 for (; ; ) {
4131  26 chLocal = charAt(bp + (offset++));
4132  26 if (chLocal >= '0' && chLocal <= '9') {
4133  24 millis = millis * 10 + (chLocal - '0');
4134    } else {
4135  2 break;
4136    }
4137    }
4138    }
4139   
4140  2 if (millis < 0) {
4141  0 matchStat = NOT_MATCH;
4142  0 return null;
4143    }
4144   
4145  2 if (negative) {
4146  0 millis = -millis;
4147    }
4148   
4149  2 dateVal = new java.util.Date(millis);
4150  2 } else if (chLocal == 'n' &&
4151    charAt(bp + offset) == 'u' &&
4152    charAt(bp + offset + 1) == 'l' &&
4153    charAt(bp + offset + 2) == 'l') {
4154  2 matchStat = VALUE_NULL;
4155  2 dateVal = null;
4156  2 offset += 3;
4157  2 chLocal = charAt(bp + offset++);
4158    } else {
4159  0 matchStat = NOT_MATCH;
4160  0 return null;
4161    }
4162   
4163  6 if (chLocal == ',') {
4164  3 bp += offset;
4165  3 this.ch = this.charAt(bp);
4166  3 matchStat = VALUE;
4167  3 token = JSONToken.COMMA;
4168  3 return dateVal;
4169    }
4170   
4171  3 if (chLocal == ']') {
4172  3 chLocal = charAt(bp + (offset++));
4173  3 if (chLocal == ',') {
4174  0 token = JSONToken.COMMA;
4175  0 bp += offset;
4176  0 this.ch = this.charAt(bp);
4177  3 } else if (chLocal == ']') {
4178  0 token = JSONToken.RBRACKET;
4179  0 bp += offset;
4180  0 this.ch = this.charAt(bp);
4181  3 } else if (chLocal == '}') {
4182  0 token = JSONToken.RBRACE;
4183  0 bp += offset;
4184  0 this.ch = this.charAt(bp);
4185  3 } else if (chLocal == EOI) {
4186  3 token = JSONToken.EOF;
4187  3 bp += (offset - 1);
4188  3 ch = EOI;
4189    } else {
4190  0 matchStat = NOT_MATCH;
4191  0 return null;
4192    }
4193  3 matchStat = END;
4194    } else {
4195  0 matchStat = NOT_MATCH;
4196  0 return null;
4197    }
4198   
4199  3 return dateVal;
4200    }
4201   
 
4202  185 toggle public java.util.UUID scanFieldUUID(char[] fieldName) {
4203  185 matchStat = UNKNOWN;
4204   
4205  185 if (!charArrayCompare(fieldName)) {
4206  155 matchStat = NOT_MATCH_NAME;
4207  155 return null;
4208    }
4209   
4210    // int index = bp + fieldName.length;
4211   
4212  30 int offset = fieldName.length;
4213  30 char chLocal = charAt(bp + (offset++));
4214   
4215  30 final java.util.UUID uuid;
4216  30 if (chLocal == '"') {
4217  29 int startIndex = bp + fieldName.length + 1;
4218  29 int endIndex = indexOf('"', startIndex);
4219  29 if (endIndex == -1) {
4220  0 throw new JSONException("unclosed str");
4221    }
4222   
4223  29 int startIndex2 = bp + fieldName.length + 1; // must re compute
4224  29 int len = endIndex - startIndex2;
4225  29 if (len == 36) {
4226  2 long mostSigBits = 0, leastSigBits = 0;
4227  18 for (int i = 0; i < 8; ++i) {
4228  16 char ch = charAt(startIndex2 + i);
4229  16 int num;
4230  16 if (ch >= '0' && ch <= '9') {
4231  11 num = ch - '0';
4232  5 } else if (ch >= 'a' && ch <= 'f') {
4233  5 num = 10 + (ch - 'a');
4234  0 } else if (ch >= 'A' && ch <= 'F') {
4235  0 num = 10 + (ch - 'A');
4236    } else {
4237  0 matchStat = NOT_MATCH_NAME;
4238  0 return null;
4239    }
4240   
4241  16 mostSigBits <<= 4;
4242  16 mostSigBits |= num;
4243    }
4244  10 for (int i = 9; i < 13; ++i) {
4245  8 char ch = charAt(startIndex2 + i);
4246  8 int num;
4247  8 if (ch >= '0' && ch <= '9') {
4248  3 num = ch - '0';
4249  5 } else if (ch >= 'a' && ch <= 'f') {
4250  3 num = 10 + (ch - 'a');
4251  2 } else if (ch >= 'A' && ch <= 'F') {
4252  2 num = 10 + (ch - 'A');
4253    } else {
4254  0 matchStat = NOT_MATCH_NAME;
4255  0 return null;
4256    }
4257   
4258  8 mostSigBits <<= 4;
4259  8 mostSigBits |= num;
4260    }
4261  10 for (int i = 14; i < 18; ++i) {
4262  8 char ch = charAt(startIndex2 + i);
4263  8 int num;
4264  8 if (ch >= '0' && ch <= '9') {
4265  5 num = ch - '0';
4266  3 } else if (ch >= 'a' && ch <= 'f') {
4267  2 num = 10 + (ch - 'a');
4268  1 } else if (ch >= 'A' && ch <= 'F') {
4269  1 num = 10 + (ch - 'A');
4270    } else {
4271  0 matchStat = NOT_MATCH_NAME;
4272  0 return null;
4273    }
4274   
4275  8 mostSigBits <<= 4;
4276  8 mostSigBits |= num;
4277    }
4278  10 for (int i = 19; i < 23; ++i) {
4279  8 char ch = charAt(startIndex2 + i);
4280  8 int num;
4281  8 if (ch >= '0' && ch <= '9') {
4282  3 num = ch - '0';
4283  5 } else if (ch >= 'a' && ch <= 'f') {
4284  4 num = 10 + (ch - 'a');
4285  1 } else if (ch >= 'A' && ch <= 'F') {
4286  1 num = 10 + (ch - 'A');
4287    } else {
4288  0 matchStat = NOT_MATCH_NAME;
4289  0 return null;
4290    }
4291   
4292  8 leastSigBits <<= 4;
4293  8 leastSigBits |= num;
4294    }
4295  26 for (int i = 24; i < 36; ++i) {
4296  24 char ch = charAt(startIndex2 + i);
4297  24 int num;
4298  24 if (ch >= '0' && ch <= '9') {
4299  16 num = ch - '0';
4300  8 } else if (ch >= 'a' && ch <= 'f') {
4301  3 num = 10 + (ch - 'a');
4302  5 } else if (ch >= 'A' && ch <= 'F') {
4303  5 num = 10 + (ch - 'A');
4304    } else {
4305  0 matchStat = NOT_MATCH_NAME;
4306  0 return null;
4307    }
4308   
4309  24 leastSigBits <<= 4;
4310  24 leastSigBits |= num;
4311    }
4312  2 uuid = new UUID(mostSigBits, leastSigBits);
4313   
4314  2 offset += (endIndex - (bp + fieldName.length + 1) + 1);
4315  2 chLocal = charAt(bp + (offset++));
4316  27 } else if (len == 32) {
4317  0 long mostSigBits = 0, leastSigBits = 0;
4318  0 for (int i = 0; i < 16; ++i) {
4319  0 char ch = charAt(startIndex2 + i);
4320  0 int num;
4321  0 if (ch >= '0' && ch <= '9') {
4322  0 num = ch - '0';
4323  0 } else if (ch >= 'a' && ch <= 'f') {
4324  0 num = 10 + (ch - 'a');
4325  0 } else if (ch >= 'A' && ch <= 'F') {
4326  0 num = 10 + (ch - 'A');
4327    } else {
4328  0 matchStat = NOT_MATCH_NAME;
4329  0 return null;
4330    }
4331   
4332  0 mostSigBits <<= 4;
4333  0 mostSigBits |= num;
4334    }
4335  0 for (int i = 16; i < 32; ++i) {
4336  0 char ch = charAt(startIndex2 + i);
4337  0 int num;
4338  0 if (ch >= '0' && ch <= '9') {
4339  0 num = ch - '0';
4340  0 } else if (ch >= 'a' && ch <= 'f') {
4341  0 num = 10 + (ch - 'a');
4342  0 } else if (ch >= 'A' && ch <= 'F') {
4343  0 num = 10 + (ch - 'A');
4344    } else {
4345  0 matchStat = NOT_MATCH_NAME;
4346  0 return null;
4347    }
4348   
4349  0 leastSigBits <<= 4;
4350  0 leastSigBits |= num;
4351    }
4352   
4353  0 uuid = new UUID(mostSigBits, leastSigBits);
4354   
4355  0 offset += (endIndex - (bp + fieldName.length + 1) + 1);
4356  0 chLocal = charAt(bp + (offset++));
4357    } else {
4358  27 matchStat = NOT_MATCH;
4359  27 return null;
4360    }
4361  1 } else if (chLocal == 'n'
4362    && charAt(bp + (offset++)) == 'u'
4363    && charAt(bp + (offset++)) == 'l'
4364    && charAt(bp + (offset++)) == 'l') {
4365  1 uuid = null;
4366  1 chLocal = charAt(bp + (offset++));
4367    } else {
4368  0 matchStat = NOT_MATCH;
4369  0 return null;
4370    }
4371   
4372  3 if (chLocal == ',') {
4373  0 bp += offset;
4374  0 this.ch = this.charAt(bp);
4375  0 matchStat = VALUE;
4376  0 return uuid;
4377    }
4378   
4379  3 if (chLocal == '}') {
4380  3 chLocal = charAt(bp + (offset++));
4381  3 if (chLocal == ',') {
4382  0 token = JSONToken.COMMA;
4383  0 bp += offset;
4384  0 this.ch = this.charAt(bp);
4385  3 } else if (chLocal == ']') {
4386  0 token = JSONToken.RBRACKET;
4387  0 bp += offset;
4388  0 this.ch = this.charAt(bp);
4389  3 } else if (chLocal == '}') {
4390  0 token = JSONToken.RBRACE;
4391  0 bp += offset;
4392  0 this.ch = this.charAt(bp);
4393  3 } else if (chLocal == EOI) {
4394  3 token = JSONToken.EOF;
4395  3 bp += (offset - 1);
4396  3 ch = EOI;
4397    } else {
4398  0 matchStat = NOT_MATCH;
4399  0 return null;
4400    }
4401  3 matchStat = END;
4402    } else {
4403  0 matchStat = NOT_MATCH;
4404  0 return null;
4405    }
4406   
4407  3 return uuid;
4408    }
4409   
 
4410  0 toggle public java.util.UUID scanUUID(char seperator) {
4411  0 matchStat = UNKNOWN;
4412   
4413    // int index = bp + fieldName.length;
4414   
4415  0 int offset = 0;
4416  0 char chLocal = charAt(bp + (offset++));
4417   
4418  0 final java.util.UUID uuid;
4419  0 if (chLocal == '"') {
4420  0 int startIndex = bp + 1;
4421  0 int endIndex = indexOf('"', startIndex);
4422  0 if (endIndex == -1) {
4423  0 throw new JSONException("unclosed str");
4424    }
4425   
4426  0 int startIndex2 = bp + 1; // must re compute
4427  0 int len = endIndex - startIndex2;
4428  0 if (len == 36) {
4429  0 long mostSigBits = 0, leastSigBits = 0;
4430  0 for (int i = 0; i < 8; ++i) {
4431  0 char ch = charAt(startIndex2 + i);
4432  0 int num;
4433  0 if (ch >= '0' && ch <= '9') {
4434  0 num = ch - '0';
4435  0 } else if (ch >= 'a' && ch <= 'f') {
4436  0 num = 10 + (ch - 'a');
4437  0 } else if (ch >= 'A' && ch <= 'F') {
4438  0 num = 10 + (ch - 'A');
4439    } else {
4440  0 matchStat = NOT_MATCH_NAME;
4441  0 return null;
4442    }
4443   
4444  0 mostSigBits <<= 4;
4445  0 mostSigBits |= num;
4446    }
4447  0 for (int i = 9; i < 13; ++i) {
4448  0 char ch = charAt(startIndex2 + i);
4449  0 int num;
4450  0 if (ch >= '0' && ch <= '9') {
4451  0 num = ch - '0';
4452  0 } else if (ch >= 'a' && ch <= 'f') {
4453  0 num = 10 + (ch - 'a');
4454  0 } else if (ch >= 'A' && ch <= 'F') {
4455  0 num = 10 + (ch - 'A');
4456    } else {
4457  0 matchStat = NOT_MATCH_NAME;
4458  0 return null;
4459    }
4460   
4461  0 mostSigBits <<= 4;
4462  0 mostSigBits |= num;
4463    }
4464  0 for (int i = 14; i < 18; ++i) {
4465  0 char ch = charAt(startIndex2 + i);
4466  0 int num;
4467  0 if (ch >= '0' && ch <= '9') {
4468  0 num = ch - '0';
4469  0 } else if (ch >= 'a' && ch <= 'f') {
4470  0 num = 10 + (ch - 'a');
4471  0 } else if (ch >= 'A' && ch <= 'F') {
4472  0 num = 10 + (ch - 'A');
4473    } else {
4474  0 matchStat = NOT_MATCH_NAME;
4475  0 return null;
4476    }
4477   
4478  0 mostSigBits <<= 4;
4479  0 mostSigBits |= num;
4480    }
4481  0 for (int i = 19; i < 23; ++i) {
4482  0 char ch = charAt(startIndex2 + i);
4483  0 int num;
4484  0 if (ch >= '0' && ch <= '9') {
4485  0 num = ch - '0';
4486  0 } else if (ch >= 'a' && ch <= 'f') {
4487  0 num = 10 + (ch - 'a');
4488  0 } else if (ch >= 'A' && ch <= 'F') {
4489  0 num = 10 + (ch - 'A');
4490    } else {
4491  0 matchStat = NOT_MATCH_NAME;
4492  0 return null;
4493    }
4494   
4495  0 leastSigBits <<= 4;
4496  0 leastSigBits |= num;
4497    }
4498  0 for (int i = 24; i < 36; ++i) {
4499  0 char ch = charAt(startIndex2 + i);
4500  0 int num;
4501  0 if (ch >= '0' && ch <= '9') {
4502  0 num = ch - '0';
4503  0 } else if (ch >= 'a' && ch <= 'f') {
4504  0 num = 10 + (ch - 'a');
4505  0 } else if (ch >= 'A' && ch <= 'F') {
4506  0 num = 10 + (ch - 'A');
4507    } else {
4508  0 matchStat = NOT_MATCH_NAME;
4509  0 return null;
4510    }
4511   
4512  0 leastSigBits <<= 4;
4513  0 leastSigBits |= num;
4514    }
4515  0 uuid = new UUID(mostSigBits, leastSigBits);
4516   
4517  0 offset += (endIndex - (bp + 1) + 1);
4518  0 chLocal = charAt(bp + (offset++));
4519  0 } else if (len == 32) {
4520  0 long mostSigBits = 0, leastSigBits = 0;
4521  0 for (int i = 0; i < 16; ++i) {
4522  0 char ch = charAt(startIndex2 + i);
4523  0 int num;
4524  0 if (ch >= '0' && ch <= '9') {
4525  0 num = ch - '0';
4526  0 } else if (ch >= 'a' && ch <= 'f') {
4527  0 num = 10 + (ch - 'a');
4528  0 } else if (ch >= 'A' && ch <= 'F') {
4529  0 num = 10 + (ch - 'A');
4530    } else {
4531  0 matchStat = NOT_MATCH_NAME;
4532  0 return null;
4533    }
4534   
4535  0 mostSigBits <<= 4;
4536  0 mostSigBits |= num;
4537    }
4538  0 for (int i = 16; i < 32; ++i) {
4539  0 char ch = charAt(startIndex2 + i);
4540  0 int num;
4541  0 if (ch >= '0' && ch <= '9') {
4542  0 num = ch - '0';
4543  0 } else if (ch >= 'a' && ch <= 'f') {
4544  0 num = 10 + (ch - 'a');
4545  0 } else if (ch >= 'A' && ch <= 'F') {
4546  0 num = 10 + (ch - 'A');
4547    } else {
4548  0 matchStat = NOT_MATCH_NAME;
4549  0 return null;
4550    }
4551   
4552  0 leastSigBits <<= 4;
4553  0 leastSigBits |= num;
4554    }
4555   
4556  0 uuid = new UUID(mostSigBits, leastSigBits);
4557   
4558  0 offset += (endIndex - (bp + 1) + 1);
4559  0 chLocal = charAt(bp + (offset++));
4560    } else {
4561  0 matchStat = NOT_MATCH;
4562  0 return null;
4563    }
4564  0 } else if (chLocal == 'n'
4565    && charAt(bp + (offset++)) == 'u'
4566    && charAt(bp + (offset++)) == 'l'
4567    && charAt(bp + (offset++)) == 'l') {
4568  0 uuid = null;
4569  0 chLocal = charAt(bp + (offset++));
4570    } else {
4571  0 matchStat = NOT_MATCH;
4572  0 return null;
4573    }
4574   
4575  0 if (chLocal == ',') {
4576  0 bp += offset;
4577  0 this.ch = this.charAt(bp);
4578  0 matchStat = VALUE;
4579  0 return uuid;
4580    }
4581   
4582  0 if (chLocal == ']') {
4583  0 chLocal = charAt(bp + (offset++));
4584  0 if (chLocal == ',') {
4585  0 token = JSONToken.COMMA;
4586  0 bp += offset;
4587  0 this.ch = this.charAt(bp);
4588  0 } else if (chLocal == ']') {
4589  0 token = JSONToken.RBRACKET;
4590  0 bp += offset;
4591  0 this.ch = this.charAt(bp);
4592  0 } else if (chLocal == '}') {
4593  0 token = JSONToken.RBRACE;
4594  0 bp += offset;
4595  0 this.ch = this.charAt(bp);
4596  0 } else if (chLocal == EOI) {
4597  0 token = JSONToken.EOF;
4598  0 bp += (offset - 1);
4599  0 ch = EOI;
4600    } else {
4601  0 matchStat = NOT_MATCH;
4602  0 return null;
4603    }
4604  0 matchStat = END;
4605    } else {
4606  0 matchStat = NOT_MATCH;
4607  0 return null;
4608    }
4609   
4610  0 return uuid;
4611    }
4612   
 
4613  611 toggle public final void scanTrue() {
4614  611 if (ch != 't') {
4615  1 throw new JSONException("error parse true");
4616    }
4617  610 next();
4618   
4619  610 if (ch != 'r') {
4620  6 throw new JSONException("error parse true");
4621    }
4622  604 next();
4623   
4624  604 if (ch != 'u') {
4625  5 throw new JSONException("error parse true");
4626    }
4627  599 next();
4628   
4629  599 if (ch != 'e') {
4630  5 throw new JSONException("error parse true");
4631    }
4632  594 next();
4633   
4634  594 if (ch == ' ' ||
4635    ch == ',' ||
4636    ch == '}' ||
4637    ch == ']' ||
4638    ch == '\n' ||
4639    ch == '\r' ||
4640    ch == '\t' ||
4641    ch == EOI ||
4642    ch == '\f' ||
4643    ch == '\b' ||
4644    ch == ':' ||
4645    ch == '/') {
4646  591 token = JSONToken.TRUE;
4647    } else {
4648  3 throw new JSONException("scan true error");
4649    }
4650    }
4651   
 
4652  5724 toggle public final void scanNullOrNew() {
4653  5724 scanNullOrNew(true);
4654    }
4655   
 
4656  5740 toggle public final void scanNullOrNew(boolean acceptColon) {
4657  5740 if (ch != 'n') {
4658  1 throw new JSONException("error parse null or new");
4659    }
4660  5739 next();
4661   
4662  5739 if (ch == 'u') {
4663  5697 next();
4664  5697 if (ch != 'l') {
4665  4 throw new JSONException("error parse null");
4666    }
4667  5693 next();
4668   
4669  5693 if (ch != 'l') {
4670  5 throw new JSONException("error parse null");
4671    }
4672  5688 next();
4673   
4674   
4675  5688 if (ch == ' '
4676    || ch == ','
4677    || ch == '}'
4678    || ch == ']'
4679    || ch == '\n'
4680    || ch == '\r'
4681    || ch == '\t'
4682    || ch == EOI
4683    || (ch == ':' && acceptColon)
4684    || ch == '\f'
4685    || ch == '\b') {
4686   
4687  5684 token = JSONToken.NULL;
4688    } else {
4689  4 throw new JSONException("scan null error");
4690    }
4691  5684 return;
4692    }
4693   
4694  42 if (ch != 'e') {
4695  15 throw new JSONException("error parse new");
4696    }
4697  27 next();
4698   
4699  27 if (ch != 'w') {
4700  2 throw new JSONException("error parse new");
4701    }
4702  25 next();
4703   
4704  25 if (ch == ' ' ||
4705    ch == ',' ||
4706    ch == '}' ||
4707    ch == ']' ||
4708    ch == '\n' ||
4709    ch == '\r' ||
4710    ch == '\t' ||
4711    ch == EOI ||
4712    ch == '\f' ||
4713    ch == '\b') {
4714  22 token = JSONToken.NEW;
4715    } else {
4716  3 throw new JSONException("scan new error");
4717    }
4718    }
4719   
 
4720  2528 toggle public final void scanFalse() {
4721  2528 if (ch != 'f') {
4722  1 throw new JSONException("error parse false");
4723    }
4724  2527 next();
4725   
4726  2527 if (ch != 'a') {
4727  4 throw new JSONException("error parse false");
4728    }
4729  2523 next();
4730   
4731  2523 if (ch != 'l') {
4732  4 throw new JSONException("error parse false");
4733    }
4734  2519 next();
4735   
4736  2519 if (ch != 's') {
4737  5 throw new JSONException("error parse false");
4738    }
4739  2514 next();
4740   
4741  2514 if (ch != 'e') {
4742  5 throw new JSONException("error parse false");
4743    }
4744  2509 next();
4745   
4746  2509 if (ch == ' ' ||
4747    ch == ',' ||
4748    ch == '}' ||
4749    ch == ']' ||
4750    ch == '\n' ||
4751    ch == '\r' ||
4752    ch == '\t' ||
4753    ch == EOI ||
4754    ch == '\f' ||
4755    ch == '\b' ||
4756    ch == ':' ||
4757    ch == '/') {
4758  2507 token = JSONToken.FALSE;
4759    } else {
4760  2 throw new JSONException("scan false error");
4761    }
4762    }
4763   
 
4764  72 toggle public final void scanIdent() {
4765  72 np = bp - 1;
4766  72 hasSpecial = false;
4767   
4768  72 for (;;) {
4769  297 sp++;
4770   
4771  297 next();
4772  297 if (Character.isLetterOrDigit(ch)) {
4773  225 continue;
4774    }
4775   
4776  72 String ident = stringVal();
4777   
4778  72 if ("null".equalsIgnoreCase(ident)) {
4779  3 token = JSONToken.NULL;
4780  69 } else if ("new".equals(ident)) {
4781  1 token = JSONToken.NEW;
4782  68 } else if ("true".equals(ident)) {
4783  1 token = JSONToken.TRUE;
4784  67 } else if ("false".equals(ident)) {
4785  1 token = JSONToken.FALSE;
4786  66 } else if ("undefined".equals(ident)) {
4787  11 token = JSONToken.UNDEFINED;
4788  55 } else if ("Set".equals(ident)) {
4789  8 token = JSONToken.SET;
4790  47 } else if ("TreeSet".equals(ident)) {
4791  3 token = JSONToken.TREE_SET;
4792    } else {
4793  44 token = JSONToken.IDENTIFIER;
4794    }
4795  72 return;
4796    }
4797    }
4798   
4799    public abstract String stringVal();
4800   
4801    public abstract String subString(int offset, int count);
4802   
4803    protected abstract char[] sub_chars(int offset, int count);
4804   
 
4805  1098 toggle public static String readString(char[] chars, int chars_len) {
4806  1098 char[] sbuf = new char[chars_len];
4807  1098 int len = 0;
4808  892303 for (int i = 0; i < chars_len; ++i) {
4809  891206 char ch = chars[i];
4810   
4811  891206 if (ch != '\\') {
4812  691803 sbuf[len++] = ch;
4813  691803 continue;
4814    }
4815  199403 ch = chars[++i];
4816   
4817  199403 switch (ch) {
4818  2 case '0':
4819  2 sbuf[len++] = '\0';
4820  2 break;
4821  2 case '1':
4822  2 sbuf[len++] = '\1';
4823  2 break;
4824  2 case '2':
4825  2 sbuf[len++] = '\2';
4826  2 break;
4827  2 case '3':
4828  2 sbuf[len++] = '\3';
4829  2 break;
4830  2 case '4':
4831  2 sbuf[len++] = '\4';
4832  2 break;
4833  2 case '5':
4834  2 sbuf[len++] = '\5';
4835  2 break;
4836  2 case '6':
4837  2 sbuf[len++] = '\6';
4838  2 break;
4839  2 case '7':
4840  2 sbuf[len++] = '\7';
4841  2 break;
4842  29 case 'b': // 8
4843  29 sbuf[len++] = '\b';
4844  29 break;
4845  36 case 't': // 9
4846  36 sbuf[len++] = '\t';
4847  36 break;
4848  50 case 'n': // 10
4849  50 sbuf[len++] = '\n';
4850  50 break;
4851  2 case 'v': // 11
4852  2 sbuf[len++] = '\u000B';
4853  2 break;
4854  23 case 'f': // 12
4855  1 case 'F':
4856  24 sbuf[len++] = '\f';
4857  24 break;
4858  53 case 'r': // 13
4859  53 sbuf[len++] = '\r';
4860  53 break;
4861  52 case '"': // 34
4862  52 sbuf[len++] = '"';
4863  52 break;
4864  2 case '\'': // 39
4865  2 sbuf[len++] = '\'';
4866  2 break;
4867  5 case '/': // 47
4868  5 sbuf[len++] = '/';
4869  5 break;
4870  42 case '\\': // 92
4871  42 sbuf[len++] = '\\';
4872  42 break;
4873  1 case 'x':
4874  1 sbuf[len++] = (char) (digits[chars[++i]] * 16 + digits[chars[++i]]);
4875  1 break;
4876  199090 case 'u':
4877  199090 sbuf[len++] = (char) Integer.parseInt(new String(new char[] { chars[++i], //
4878    chars[++i], //
4879    chars[++i], //
4880    chars[++i] }),
4881    16);
4882  199090 break;
4883  1 default:
4884  1 throw new JSONException("unclosed.str.lit");
4885    }
4886    }
4887  1097 return new String(sbuf, 0, len);
4888    }
4889   
4890    protected abstract boolean charArrayCompare(char[] chars);
4891   
 
4892  46 toggle public boolean isBlankInput() {
4893  46 for (int i = 0;; ++i) {
4894  50 char chLocal = charAt(i);
4895  50 if (chLocal == EOI) {
4896  26 token = JSONToken.EOF;
4897  26 break;
4898    }
4899   
4900  24 if (!isWhitespace(chLocal)) {
4901  20 return false;
4902    }
4903    }
4904   
4905  26 return true;
4906    }
4907   
 
4908  20390905 toggle public final void skipWhitespace() {
4909  20390905 for (;;) {
4910  20426040 if (ch <= '/') {
4911  5263427 if (ch == ' ' ||
4912    ch == '\r' ||
4913    ch == '\n' ||
4914    ch == '\t' ||
4915    ch == '\f' ||
4916    ch == '\b') {
4917  35110 next();
4918  35110 continue;
4919  5228317 } else if (ch == '/') {
4920  26 skipComment();
4921  25 continue;
4922    } else {
4923  5228291 break;
4924    }
4925    } else {
4926  15162613 break;
4927    }
4928    }
4929    }
4930   
 
4931  41 toggle private void scanStringSingleQuote() {
4932  41 np = bp;
4933  41 hasSpecial = false;
4934  41 char chLocal;
4935  41 for (;;) {
4936  13996 chLocal = next();
4937   
4938  13996 if (chLocal == '\'') {
4939  36 break;
4940    }
4941   
4942  13960 if (chLocal == EOI) {
4943  1 if (!isEOF()) {
4944  0 putChar((char) EOI);
4945  0 continue;
4946    }
4947  1 throw new JSONException("unclosed single-quote string");
4948    }
4949   
4950  13959 if (chLocal == '\\') {
4951  1813 if (!hasSpecial) {
4952  8 hasSpecial = true;
4953   
4954  8 if (sp > sbuf.length) {
4955  0 char[] newsbuf = new char[sp * 2];
4956  0 System.arraycopy(sbuf, 0, newsbuf, 0, sbuf.length);
4957  0 sbuf = newsbuf;
4958    }
4959   
4960    // text.getChars(offset, offset + count, dest, 0);
4961  8 this.copyTo(np + 1, sp, sbuf);
4962    // System.arraycopy(buf, np + 1, sbuf, 0, sp);
4963    }
4964   
4965  1813 chLocal = next();
4966   
4967  1813 switch (chLocal) {
4968  0 case '0':
4969  0 putChar('\0');
4970  0 break;
4971  0 case '1':
4972  0 putChar('\1');
4973  0 break;
4974  0 case '2':
4975  0 putChar('\2');
4976  0 break;
4977  0 case '3':
4978  0 putChar('\3');
4979  0 break;
4980  0 case '4':
4981  0 putChar('\4');
4982  0 break;
4983  0 case '5':
4984  0 putChar('\5');
4985  0 break;
4986  0 case '6':
4987  0 putChar('\6');
4988  0 break;
4989  0 case '7':
4990  0 putChar('\7');
4991  0 break;
4992  201 case 'b': // 8
4993  201 putChar('\b');
4994  201 break;
4995  400 case 't': // 9
4996  400 putChar('\t');
4997  400 break;
4998  201 case 'n': // 10
4999  201 putChar('\n');
5000  201 break;
5001  0 case 'v': // 11
5002  0 putChar('\u000B');
5003  0 break;
5004  201 case 'f': // 12
5005  0 case 'F':
5006  201 putChar('\f');
5007  201 break;
5008  201 case 'r': // 13
5009  201 putChar('\r');
5010  201 break;
5011  1 case '"': // 34
5012  1 putChar('"');
5013  1 break;
5014  1 case '\'': // 39
5015  1 putChar('\'');
5016  1 break;
5017  201 case '/': // 47
5018  201 putChar('/');
5019  201 break;
5020  201 case '\\': // 92
5021  201 putChar('\\');
5022  201 break;
5023  3 case 'x':
5024  3 char x1 = next();
5025  3 char x2 = next();
5026   
5027  3 boolean hex1 = (x1 >= '0' && x1 <= '9')
5028    || (x1 >= 'a' && x1 <= 'f')
5029    || (x1 >= 'A' && x1 <= 'F');
5030  3 boolean hex2 = (x2 >= '0' && x2 <= '9')
5031    || (x2 >= 'a' && x2 <= 'f')
5032    || (x2 >= 'A' && x2 <= 'F');
5033  3 if (!hex1 || !hex2) {
5034  3 throw new JSONException("invalid escape character \\x" + x1 + x2);
5035    }
5036   
5037  0 putChar((char) (digits[x1] * 16 + digits[x2]));
5038  0 break;
5039  201 case 'u':
5040  201 putChar((char) Integer.parseInt(new String(new char[] { next(), next(), next(), next() }), 16));
5041  201 break;
5042  1 default:
5043  1 this.ch = chLocal;
5044  1 throw new JSONException("unclosed single-quote string");
5045    }
5046  1809 continue;
5047    }
5048   
5049  12146 if (!hasSpecial) {
5050  6145 sp++;
5051  6145 continue;
5052    }
5053   
5054  6001 if (sp == sbuf.length) {
5055  3 putChar(chLocal);
5056    } else {
5057  5998 sbuf[sp++] = chLocal;
5058    }
5059    }
5060   
5061  36 token = LITERAL_STRING;
5062  36 this.next();
5063    }
5064   
5065    /**
5066    * Append a character to sbuf.
5067    */
 
5068  1210789 toggle protected final void putChar(char ch) {
5069  1210789 if (sp == sbuf.length) {
5070  43 char[] newsbuf = new char[sbuf.length * 2];
5071  43 System.arraycopy(sbuf, 0, newsbuf, 0, sbuf.length);
5072  43 sbuf = newsbuf;
5073    }
5074  1210789 sbuf[sp++] = ch;
5075    }
5076   
 
5077  4 toggle public final void scanHex() {
5078  4 if (ch != 'x') {
5079  0 throw new JSONException("illegal state. " + ch);
5080    }
5081  4 next();
5082  4 if (ch != '\'') {
5083  0 throw new JSONException("illegal state. " + ch);
5084    }
5085   
5086  4 np = bp;
5087  4 next();
5088   
5089  4 if (ch == '\'') {
5090  1 next();
5091  1 token = JSONToken.HEX;
5092  1 return;
5093    }
5094   
5095  3 for (int i = 0;;++i) {
5096  76 char ch = next();
5097  76 if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F')) {
5098  73 sp++;
5099  73 continue;
5100  3 } else if (ch == '\'') {
5101  3 sp++;
5102  3 next();
5103  3 break;
5104    } else {
5105  0 throw new JSONException("illegal state. " + ch);
5106    }
5107    }
5108  3 token = JSONToken.HEX;
5109    }
5110   
 
5111  15124267 toggle public final void scanNumber() {
5112  15124267 np = bp;
5113   
5114  15124267 if (ch == '-') {
5115  14240 sp++;
5116  14240 next();
5117    }
5118   
5119  15124267 for (;;) {
5120  30870111 if (ch >= '0' && ch <= '9') {
5121  15745844 sp++;
5122    } else {
5123  15124267 break;
5124    }
5125  15745844 next();
5126    }
5127   
5128  15124267 boolean isDouble = false;
5129   
5130  15124267 if (ch == '.') {
5131  14010256 sp++;
5132  14010256 next();
5133  14010256 isDouble = true;
5134   
5135  14010256 for (;;) {
5136  138040650 if (ch >= '0' && ch <= '9') {
5137  124030394 sp++;
5138    } else {
5139  14010256 break;
5140    }
5141  124030394 next();
5142    }
5143    }
5144   
5145  15124267 if (ch == 'L') {
5146  39 sp++;
5147  39 next();
5148  15124228 } else if (ch == 'S') {
5149  15 sp++;
5150  15 next();
5151  15124213 } else if (ch == 'B') {
5152  24 sp++;
5153  24 next();
5154  15124189 } else if (ch == 'F') {
5155  20 sp++;
5156  20 next();
5157  20 isDouble = true;
5158  15124169 } else if (ch == 'D') {
5159  8012 sp++;
5160  8012 next();
5161  8012 isDouble = true;
5162  15116157 } else if (ch == 'e' || ch == 'E') {
5163  14027 sp++;
5164  14027 next();
5165   
5166  14027 if (ch == '+' || ch == '-') {
5167  13982 sp++;
5168  13982 next();
5169    }
5170   
5171  14027 for (;;) {
5172  28271 if (ch >= '0' && ch <= '9') {
5173  14244 sp++;
5174    } else {
5175  14027 break;
5176    }
5177  14244 next();
5178    }
5179   
5180  14027 if (ch == 'D' || ch == 'F') {
5181  5 sp++;
5182  5 next();
5183    }
5184   
5185  14027 isDouble = true;
5186    }
5187   
5188  15124267 if (isDouble) {
5189  14010321 token = JSONToken.LITERAL_FLOAT;
5190    } else {
5191  1113946 token = JSONToken.LITERAL_INT;
5192    }
5193    }
5194   
 
5195  6435 toggle public final long longValue() throws NumberFormatException {
5196  6435 long result = 0;
5197  6435 boolean negative = false;
5198  6435 long limit;
5199  6435 int digit;
5200   
5201  6435 if (np == -1) {
5202  0 np = 0;
5203    }
5204   
5205  6435 int i = np, max = np + sp;
5206   
5207  6435 if (charAt(np) == '-') {
5208  3871 negative = true;
5209  3871 limit = Long.MIN_VALUE;
5210  3871 i++;
5211    } else {
5212  2564 limit = -Long.MAX_VALUE;
5213    }
5214  6435 long multmin = MULTMIN_RADIX_TEN;
5215  6435 if (i < max) {
5216  6434 digit = charAt(i++) - '0';
5217  6434 result = -digit;
5218    }
5219  103894 while (i < max) {
5220    // Accumulating negatively avoids surprises near MAX_VALUE
5221  97481 char chLocal = charAt(i++);
5222   
5223  97481 if (chLocal == 'L' || chLocal == 'S' || chLocal == 'B') {
5224  14 break;
5225    }
5226   
5227  97467 digit = chLocal - '0';
5228  97467 if (result < multmin) {
5229  3 throw new NumberFormatException(numberString());
5230    }
5231  97464 result *= 10;
5232  97464 if (result < limit + digit) {
5233  5 throw new NumberFormatException(numberString());
5234    }
5235  97459 result -= digit;
5236    }
5237   
5238  6427 if (negative) {
5239  3870 if (i > np + 1) {
5240  3869 return result;
5241    } else { /* Only got "-" */
5242  1 throw new NumberFormatException(numberString());
5243    }
5244    } else {
5245  2557 return -result;
5246    }
5247    }
5248   
 
5249  4006012 toggle public final Number decimalValue(boolean decimal) {
5250  4006012 char chLocal = charAt(np + sp - 1);
5251  4006012 try {
5252  4006012 if (chLocal == 'F') {
5253  11 return Float.parseFloat(numberString());
5254    }
5255   
5256  4006001 if (chLocal == 'D') {
5257  4096 return Double.parseDouble(numberString());
5258    }
5259   
5260  4001905 if (decimal) {
5261  4000269 return decimalValue();
5262    } else {
5263  1636 return doubleValue();
5264    }
5265    } catch (NumberFormatException ex) {
5266  7 throw new JSONException(ex.getMessage() + ", " + info());
5267    }
5268    }
5269   
5270    public abstract BigDecimal decimalValue();
5271   
 
5272  4318 toggle public static boolean isWhitespace(char ch) {
5273    // 专门调整了判断顺序
5274  4318 return ch <= ' ' &&
5275    (ch == ' ' ||
5276    ch == '\n' ||
5277    ch == '\r' ||
5278    ch == '\t' ||
5279    ch == '\f' ||
5280    ch == '\b');
5281    }
5282   
5283    protected static final long MULTMIN_RADIX_TEN = Long.MIN_VALUE / 10;
5284    protected static final int INT_MULTMIN_RADIX_TEN = Integer.MIN_VALUE / 10;
5285   
5286    protected final static int[] digits = new int[(int) 'f' + 1];
5287   
 
5288  1 toggle static {
5289  11 for (int i = '0'; i <= '9'; ++i) {
5290  10 digits[i] = i - '0';
5291    }
5292   
5293  7 for (int i = 'a'; i <= 'f'; ++i) {
5294  6 digits[i] = (i - 'a') + 10;
5295    }
5296  7 for (int i = 'A'; i <= 'F'; ++i) {
5297  6 digits[i] = (i - 'A') + 10;
5298    }
5299    }
5300   
5301    /**
5302    * hsf support
5303    * @param fieldName
5304    * @param argTypesCount
5305    * @param typeSymbolTable
5306    * @return
5307    */
 
5308  0 toggle public String[] scanFieldStringArray(char[] fieldName, int argTypesCount, SymbolTable typeSymbolTable) {
5309  0 throw new UnsupportedOperationException();
5310    }
5311   
 
5312  0 toggle public boolean matchField2(char[] fieldName) {
5313  0 throw new UnsupportedOperationException();
5314    }
5315   
 
5316  13228 toggle public int getFeatures() {
5317  13228 return this.features;
5318    }
5319    }
  • Report generated by OpenClover v 4.5.2 on Tue Apr 9 2024 16:45:45 CDT using coverage data from Tue Apr 9 2024 16:43:32 CDT.
  • OpenClover is free and open-source software.